unsigned long micros() {
    unsigned long m;
    uint8_t oldSREG = SREG, t1, t2;
    uint16_t t;
    
    cli();
    m = timer0_overflow_count;
#if defined(TCNT0)
    t1 = TCNT0;
#elif defined(TCNT0L)
    t1 = TCNT0L;
#else
    #error TIMER 0 not defined
#endif

#ifdef TIFR0
    if ((TIFR0 & _BV(TOV0)) && (t1 < 255))      // if overflow flag is set -> increase m
        m++;
#else
    if ((TIFR & _BV(TOV0)) && (t1 < 255))
        m++;
#endif

#if defined(TCNT0)
    t2 = TCNT0;
#elif defined(TCNT0L)
    t2 = TCNT0L;
#else
    #error TIMER 0 not defined
#endif
    if (t1 > t2) {
        t = 510 - t2;       // counter running backwards
    } else {
        t = t2;             // counter running upwards
    }       

    SREG = oldSREG;
    
    return ((m * 510) + t)  / clockCyclesPerMicrosecond();          
}

HOWEVER - this seems to be fine but somehow there is still a bug that I could not find out. If I leave the wiring.c delay() function untouched, the while loop runs into an overflow conditition, because it seems that micros() can also decrease from one interation to another. This leads the second while clause while ( ms > 0 && (micros() - 1000) >= start) to overflow. I think this is due to micros() not steadly increasing, it might fall back below its previous value for some interation, leading to a subtraction of for example 984 - 1000 leading to the overflow condition.

What I did is simply change the statement to while ( ms > 0 && micros() >= (1000 + start)) which essentially is the same statement but much less prone to overflows. This did the trick for me and delay was running fine, now with the right timing.

Here for your reference the complete delay() function that together with the revamped micors() gives more or less correct timings for phase correct PWM at 31kHz.

void delay(unsigned long ms)
{
    uint32_t start = micros();
    
    while (ms > 0) {
        yield();
        while ( ms > 0 && micros() >= (1000 + start)) {         
            ms--;
            start += 1000;          
        }
    }
}

unsigned long micros() {
    unsigned long m;
    uint8_t oldSREG = SREG, t1, t2;
    uint16_t t;
    
    cli();
    m = timer0_overflow_count;
#if defined(TCNT0)
    t1 = TCNT0;
#elif defined(TCNT0L)
    t1 = TCNT0L;
#else
    #error TIMER 0 not defined
#endif

#if defined(TCNT0)
    t2 = TCNT0;
#elif defined(TCNT0L)
    t2 = TCNT0L;
#else
    #error TIMER 0 not defined
#endif 

    if (t1 >= t2) {
        t = 510 - t2;       // counter running backwards
    } else {
        t = t2;             // counter running upwards
    }        
    
#ifdef TIFR0
    if ((TIFR0 & _BV(TOV0)) && (t2 > 1))        // if overflow flag is set -> increase m
        m++;
#else
    if ((TIFR & _BV(TOV0)) && (t2 > 1))
        m++;
#endif

    SREG = oldSREG;
    
    return ((m * 510) + t)  / clockCyclesPerMicrosecond();          
}

HOWEVER - this seems to work fine but I had issues to begin with (before editing this again). Due to the counter running much faster, every 268 seconds the unsigned long datatype of micros() overflows and starts from zero again. This led to an unwanted lockup of delay(), especially if long delay times, like in my case delays of one second per loop iterations are used. Therefore I also had to add an overflow detection to the delay() function in arduino wiring.c.

If the overflow occurs, timing might not be very precise. But since this is once overy 268 seconds it may be acceptable. So far with this change the delay function works fine again on my side.

void delay(unsigned long ms)
{
    uint32_t start = micros();
    uint32_t elapsed = 0;   
    
    while (ms > 0) {
        yield();
        while ( ms > 0 && (micros() - 1000) >= (start + elapsed)) {         
            ms--;
            elapsed += 1000;            
        }
        if( start > micros() ) {    // overflow detected
            start = micros();       // reset start
            elapsed = 0;            // reset elapsed
        }
    }
}