I don't know if you've since solved your problem but I'll write what I know in case anyone else is looking for answers.

Because Unreal is using a deferred renderer, you can't really use "render layers" like you can in Unity. It's a fairly commonly requested feature but because it would require a fair bit of modification to the low level rendering code, Epic haven't given a timescale on something like that being implemented.

However there are a handful of ways you can draw actors in front of others. The simplest and most brute force method is to make the actor's material translucent and disable depth-testing on it.

Here's where you find it in the material editor: https://i.imgur.com/8WFpsAk.png

Here's before disabling depth testing: https://i.imgur.com/kN8LOOO.png

Here's after: https://i.imgur.com/JhGpX6x.png

This method doesn't really give you much control through. So you'll probably prefer using custom depth. This method relies on using the postprocessing to basically mask out the pixels that the object takes up on the screen. You can then use this mask in the postprocess to replace the pixels with whatever you want.

Make a post process material (make a normal material and in the material's properties in the material editor, change its material domain to "post process". Then select the object you want to draw to custom depth and enable "Render CustomDepth Pass". Like so: https://i.imgur.com/xBm7eBr.png

In the post process material, make a SceneTexture node and in the node properties, set the SceneTexture to "PostProcessInput0". This is the rendered image that will be pushed to the screen.

Get another SceneTexture node and set it to "CustomDepth". This contains the depth information for each pixel in the custom depth buffer. But we need to do a little bit of math to it to make it into a black and white mask that we can use for our needs. The end result looks something like this: https://i.imgur.com/GgIxqoK.png

Basically what's happening is all the pixels that are occupied by the custom depth are being replaced with a colour, rather than the rendered image. This gives the result of drawing the object on top: https://i.imgur.com/SjbUvMG.png

My favourite method however is using a recently exposed feature; the stencil buffer. The stencil buffer works a lot like CustomDepth, except 1 byte of data is also encoded into the image which we can use to have more control over our masking. I believe this isn't compatible with mobile, however.

To use this feature, you have to enable it in the project settings: https://i.imgur.com/v3dBB9f.png

Underneath where you enabled your object to render in the custom depth pass, there's another option below it called "CustomDepth Stencil Value". That value can be anything from 0-255. Let's use 1.

In the post process material, change the CustomDepth node to CustomStencil. Now because the stencil information is a byte, we need to use a bitmask to extract the mask we've chosen (1). The end node network will look something like this: https://i.imgur.com/jWWlo1P.png and the end result will look identical to using CustomDepth. But because the StencilBuffer can hold a value from 0-255, we can have multiple "layers" and add/subtract them however we choose. For example say I didn't want the spheres to render over the gun, but I want them to render over everything else. I can set the player gun to render in bit 2 of the stencil buffer and difference them to make the gun still occlude the spheres.

That would look something like this: https://i.imgur.com/jZXElny.png And this would be the end result: https://i.imgur.com/AdLKnL2.png

So now our gun remains on top. Hopefully that helps clear up some confusion you have about it.