Getting a fixed sampling rate
Expanding on my previous comments...

The only reliable way to get jitter-free ADC readings is to trigger the
ADC from a timer event. I wrote the following program to demonstrate the
approach on an Arduino Uno, as I don't have a Leonardo. The program
configures the Timer 1 to set it's overflow flag every 250&nbsp;µs, and
the ADC to start a conversion on every rising edge of that flag. When
the conversion is done (104&nbsp;µs after it started), the ADC ISR
fires. It's job is to retrieve the conversion result and set the analog
multiplexer for the next channel, switching round-robin through channels
0 –&nbsp;3.

volatile int adc_readings[4];
volatile bool fresh_readings;

// Used only to clear the interrupt flag.
EMPTY_INTERRUPT(TIMER1_OVF_vect);

ISR(ADC_vect)
{
    static int buffered_readings[3];
    static uint8_t channel;

    if (channel == 3) {

        // "Export" the 4 readings at once.
        adc_readings[0] = buffered_readings[0];
        adc_readings[1] = buffered_readings[1];
        adc_readings[2] = buffered_readings[2];
        adc_readings[3] = ADC;
        fresh_readings = true;
    } else {

        // Buffer the current reading.
        buffered_readings[channel] = ADC;
    }

    // Move to next channel.
    channel = (channel + 1) % 4;
    ADMUX = _BV(REFS0)  // reference = Vcc
          | channel;
}

void setup()
{
    Serial.begin(115200);
    Serial.write("================");

    // Configure the ADC.
    ADMUX  = _BV(REFS0)   // reference = Vcc
           | 0;           // channel = ADC0
    ADCSRA = _BV(ADEN)    // enable
           | _BV(ADSC)    // start first conversion
           | _BV(ADPS0)   // prescaler = 128
           | _BV(ADPS1)   // ...ditto
           | _BV(ADPS2);  // ...ditto
    ADCSRB = _BV(ADTS1)   // trigger source = Timer 1 overflow
           | _BV(ADTS2);  // ...ditto

    // Wait for and discard the first conversion.
    loop_until_bit_is_set(ADCSRA, ADIF);

    // Configure Timer 1 to overflow every 250 us.
    TCCR1A = _BV(WGM11);  // fast PWM mode, TOP = ICR1
    TCCR1B = _BV(WGM12)   // ...ditto
           | _BV(WGM13)   // ...ditto
           | _BV(CS11);   // clock at F_CPU/8
    TIMSK1 = _BV(TOIE1);  // enable overflow interrupt
    ICR1   = 500 - 1;     // period = 500 * 8 CPU cycles

    // Set the ADC to auto-trigger mode.
    ADCSRA |= _BV(ADATE)  // enable auto-trigger
            | _BV(ADIF)   // clear interrupt flag
            | _BV(ADIE);  // enable interrupt
}

void loop()
{
    if (fresh_readings) {
        Serial.write((uint8_t *) adc_readings, sizeof adc_readings);
        fresh_readings = false;
    }
}


A few comments:


The Timer 1 overflow interrupt is used only to clear the timer
interrupt flag. The flag has to be cleared because the ADC is
triggered only on it's rising edges. Alternatively, that flag could be
cleared inside the ADC ISR.
I choose to deliver the readings by batches of 4 (one reading per
channel), thus the buffering inside the ADC ISR. The choice is
arbitrary: you can, if you wish, transmit the readings as they come,
as suggested in jwpat's answer.
The very first ADC reading is manually started and discarded. The only
reason for this is that it takes longer (200&nbsp;µs instead of 104).
The readings are transmitted in binary form at 115.2&nbsp;kb/s. The
effective data rate is 80&nbsp;kb/s. ASCII would not be possible at
this sampling rate.
The loop() function must never take more than 1&nbsp;ms to execute,
otherwise there is a risk of it reading the adc_readings array while
the ADC ISR is updating it, which would lead to corrupt data.
Protecting the access to adc_readings inside a cli()/sei() pair
would not significantly ease the timing constraint, as a long loop()
execution would still carry the risk of loosing data points.


From a cursory look at the ATmega32u4
datasheet
it would seem it's Timer 1 is identical to the one of the ATmega328P
powering the Uno, save for an extra PWM channel. The ADC, however, is
slightly different, but similar enough to make porting fairly
straightforward. At least the setting of ADMUX would be different.