Nested Coroutines Waiting for Each Other

I'm currently developing a round based strategy game and run into some problems with using Coroutines. The game has nested rounds, meaning that one game round consists of several fighting rounds which respectively consist of several action rounds and so on.

I want to use coroutines to realise this game logic. My first attempt looks something like this:

     void GameStart(){
        StartCoroutine(StartGameRound());
     }
     
     IEnumerator StartGameRound(){
        foreach(...){
           yield return StartCoroutine(StartActionRound());
           yield return null; //Give control back to unity
        }
     }
     
     IEnumerator StartActionRound(){
        foreach(...){
            yield return StartCoroutine(PollForAction());
            yield return null; //Give control back to unity
        }
     }
     
     IEnumerator PollForAction(){
        while(!ActionChosen){
             yield return null; //Give control back to unity
        }
     }

I chose this structure so that each method is able to give the control back to the main execution in order to prevent freezing the game. However, as soon as i hit the first "yield return null" in the method "PollForAction" unity gives the control back to the previous coroutines. I would like the other coroutines to wait for each other before executing further. A fix could look like this:

 IEnumerator StartGameRound(){
    yield return StartCoroutine(StartActionRound);
    while(!finished)
       yield return null;
 }
 
 IEnumerator StartActionRound(){
     //ActionRound Logic
    finished = true;
 }

But to be honest I feel a bit unwell with the resulting structure of this game logic code. It looks a bit smelly. I feel I use too many unnecessary coroutines and the overall code starts to look quite complex for a relatively simple logic. However, I can't figure out a more 'neat' solution for my problem.

That is why I turn to this community: Are there any better approaches or even best practices to realise this game logic?