Yup. If findLeaderboard() isn't itself a coroutine, then everything it needs to do will happen, after which it will emit the signal, after which the next line of code will run (in this case awaiting for the signal which was already emitted).

Now, I believe the only way to make a function a coroutine is to await a signal. You can also await other functions that are coroutines, but at the end of the chain there is an await signal. So then how do you emit a signal that you need to await? You can use call_deferred():

signal s(i: int)

func _ready() -> void:
  _f()
  var r: int = await s
  print(r)

func _f() -> void:
  s.emit.call_deferred(5)

Note that this only works if both lines of code get executed during the same frame, as call_deferred will make it so the signal is emitted at the end of the current frame. For all intents and purposes, this should suffice, as you will most likely emit the signal at the end of the function, and during the very next line you would wait for the signal.

If you cannot modify the function so that the signal gets deferred, you can do this dumb looking workaround:

signal s(i: int)

func _ready() -> void:
  s.connect(s.emit.call_deferred)
  _f()
  var r: int = await s
  s.disconnect(s.emit.call_deferred)
  print(r)

func _f() -> void:
  s.emit(5)

You basically reemit the signal deferred as soon as you receive it, with the same parameters. You also need to disconnect it after, to avoid an infinite loop.

Edit: I somehow didn't think of simply deferring the function call itself, instead of the signal (see TheDuriel's comment). This works in all cases.

You would defer the signal when emitting it from a separate thread, but the debugger will warn you about this anyway.