Repetitive task within a fixed timeframe?

Ok, so I'm making an idle game in which the player earns money.

The way my code currently works is, a function that loops every second adds a penny to the player's total money for every Earner unit the player owns.

A variable called dispenseStack is also kept. It gains money at the same rate at the totalMoney variable, but they are not the same number; the dispenseStack is used to store how many coins need to be dispensed each second. It's effectively equal to all the gains of totalMoney, minus the value of all the coins dispensed (so at the end of the second, dispenseStack should equal zero and the correct change should have been dispensed).

The problem I currently have is that the code follows this order of operations:

1. Calculate earnings.

2. Dispense coins, at a rate of about one coin every 0.1 seconds.

3. Wait for a second.

4. Repeat.

The problem is, dispensing the coins evenly takes time. The end result is, the more coins being dispensed, the slower the player earns money.

For example, if the player is earning a penny every step, the end result is a gain of £0.01 every 1.1 seconds (1 second loop delay, .1 second dispense delay).

If they're earning nine pennies every step, however, the end result is a gain of £0.09 every 1.9 seconds.

This problem gets worse the longer this goes. For example, if I'm £99.99 every step, that means I'm dispensing 36 coins; a step delay of 4.6 seconds!

I need all the dispensing and calculations to happen within a single timeframe.

Any advice? I'm willing to be flexible with the mechanic. I suppose this is more a design question than a code question, but it has elements of both.

Here's the code:

     IEnumerator CoinDropper()
     {
         while(true)
         {
             // Increase Total Money
             totalMoney = totalMoney + (earnerCount * 0.01f);
             dispenseStack = dispenseStack + (earnerCount * 0.01f);
 
             // Dispense Coins
             while(dispenseStack >= 1f)
             {
                 dispenseStack = dispenseStack - 1f;
                 Vector3 spawnPosition = new Vector3 (Random.Range (-5, 5),6, Random.Range (10, 20));
                 Instantiate (goldCoin, spawnPosition, Quaternion.identity);
                 Debug.Log ("Gold Coin Dispensed");
             }
             while(dispenseStack >= 0.1f)
             {
                 dispenseStack = dispenseStack - 0.1f;
                 Vector3 spawnPosition = new Vector3 (Random.Range (-5, 5),6, Random.Range (10, 20));
                 Instantiate (silverCoin, spawnPosition, Quaternion.identity);
                 Debug.Log ("Silver Coin Dispensed");
             }
             while(dispenseStack >= 0.01f)
             {
                 dispenseStack = dispenseStack -0.01f;
                 Vector3 spawnPosition = new Vector3 (Random.Range (-5, 5),6, Random.Range (10, 20));
                 Instantiate (copperCoin, spawnPosition, Quaternion.identity);
                 Debug.Log ("Copper Coin Dispensed");
             }
             yield return new WaitForSeconds (1f);
         }
     }