Start Coroutine after other has finished

I wouldn't use a coroutine for any of this. All you need is, in Update:

 if (isRotatingToTarget) {
    transform.rotation = Quaternion.Lerp(transform.rotation, rotationToTarget , Time.deltaTime);
    isRotatingToTarget = (transform.rotation != rotationToTarget);
    if (!isRotatingToTarget) isMovingToTarget = true;
 } else if (isMovingToTarget) {
    transform.position  = Vector2.MoveTowards(transform.position, target, Time.deltaTime*movementSpeed);
    if (transform.position.x == target.x && transform.position.y == target.y) isMovingToTarget = false;
 }

The code in your question starts the RotateToTarget coroutine on every Update(). This stacks up Coroutine calls. So if your movement script would take 5 seconds to complete and your app is running at 60 fps, you have 300 coroutine running that may be accelerating the process or fighting with each other, or simply taking resources. Coroutines work well when you want independent piece of work to run without interference. If the target will be moving so this code as to reacquire it, then consider using Update() as @Pyrian suggests.

As for not completing the rotation, the issue is this line:

 transform.rotation = Quaternion.Lerp(transform.rotation, rotationToTarget , Time.deltaTime);

The way this form of Lerp works is to walk the approximately the same fraction of the remaining distance to the goal each frame. Since the distance is shrinking, the same fraction represents smaller and smaller rotations. The result is an eased movement. But the problem is that it takes a very long time to complete...and only completes due to floating point imprecision and perhaps some slop built into rotation comparison. It like the old adage, "how many days will it take to reach my goal if I walk half the distance each day." The answer is infinite...you never reach your goal. A solution is the one @YWord suggests...to use an angle threshold.

Chaining coroutines or using flags will work for what you want here, but there is an alternate. You can use 'yield' with coroutines. Here a demonstration rewrite of your code. It may not be a perfect fit since I don't have all your code, nor the context where it will be used.

 using UnityEngine;
 using System.Collections; 
 
 public class Example : MonoBehaviour {
 
     public Transform target;
     public float rotationSpeed = 5.0f;
     public float movementSpeed = 2.25f;
 
     private bool isMoving = false;
 
     void Update () {
         if (Input.GetKeyDown (KeyCode.Space)) {
             StartCoroutine(RotateThenMove());
         }
     }
 
     IEnumerator RotateThenMove() {
         if (isMoving) {
             yield break;
         }
 
         isMoving = true;
         yield return StartCoroutine(RotateToTarget());
         yield return StartCoroutine(MoveToTarget());
         isMoving = false;
     }
 
     IEnumerator RotateToTarget(){
         Quaternion rotationToTarget = Quaternion.LookRotation(target.position - transform.position);
         while(Quaternion.Angle(transform.rotation,rotationToTarget) > 0.5f) {
             transform.rotation = Quaternion.Slerp(transform.rotation, rotationToTarget , Time.deltaTime * rotationSpeed);
             yield return null;                    
         }        
     }
     
     IEnumerator MoveToTarget() {
         while(transform.position != target.position) {
             transform.position  = Vector3.MoveTowards(transform.position, target.position, Time.deltaTime*movementSpeed);
             yield return null;
         }
     }
 }   

Although starting the second coroutine in the first coroutine should work (I think), you can use a 'flag'. Note this will only work if "Can move to target" prints successfully. If it doesn't, see the paragraph at the end of this solution.

Firstly, add a new boolean to your script:

 private bool canMoveToTarget = false;

Add the following check to your update method:

 if(canMoveToTarget) StartCoroutine(MoveToTarget());

Then, set the boolean to true on the last line of RotateToTarget() and set it false on the first line of MoveToTarget().

That all said, you may want to check your vector maths. Due to the nature of Lerp, unless it receives a '1' as the final parameter, you're always going to be moving closer to the target, never equal to it. I recommend you set transform.Rotation equal to rotationToTarget once the difference between the two is small enough.