Stopwatch dependency for unit-testing
I would not return IStopwatch from Start/Stop/etc. This IStopwatch is not an immutable Value Object, like String for example: it would be easier to set expectations by having just this:

public interface IStopwatch
{
    bool IsRunning { get; }
    TimeSpan Elapsed { get; }
    void Start();
    void Stop();
    void Restart();
    void Reset();
}


SystemStopwatch would be a way shorter:

class SystemStopwatch : IStopwatch
{
    Stopwatch Stopwatch { get; } = new Stopwatch();
    public bool IsRunning =&gt; Stopwatch.IsRunning;
    public TimeSpan Elapsed =&gt; Stopwatch.Elapsed;
    public void Start() =&gt; Stopwatch.Start();
    public void Stop() =&gt; Stopwatch.Stop();
    public void Reset() =&gt; Stopwatch.Reset();
    public void Restart() =&gt; Stopwatch.Restart();
}


As for the MockStopwatch (sounds better than Debug one for me) – it could be a little bit shorter:

class MockStopwatch : IStopwatch
{
    public MockStopwatch(params TimeSpan[] intervals)
        : this(intervals.AsEnumerable())
    {
    }

    public MockStopwatch(IEnumerable&lt;TimeSpan&gt; intervals)
    {
        Interval = intervals
            .Prepend(TimeSpan.Zero)
            .ToList()
            .GetEnumerator();

        Reset();
    }

    IEnumerator&lt;TimeSpan&gt; Interval { get; }
    public bool IsRunning { get; private set; }
    public TimeSpan Elapsed =&gt;
        !IsRunning
        ? Interval.Current
        : Interval.MoveNext()
            ? Interval.Current
            : throw new InvalidOperationException("You did not define enough timestamps.");

    public void Start() =&gt; IsRunning = true;
    public void Stop() =&gt; IsRunning = false;

    public void Restart()
    {
        Stop();
        Reset();
        Start();
    }

    public void Reset()
    {
        Interval.Reset();
        Interval.MoveNext();
    }
}


Where you might need to define Prepend (.net core LINQ has one already):

static class PrependAppend
{
    public static IEnumerable&lt;T&gt; Prepend&lt;T&gt;(this IEnumerable&lt;T&gt; source, T item) =&gt;
        Enumerable.Concat(new[] { item }, source);

    public static IEnumerable&lt;T&gt; Append&lt;T&gt;(this IEnumerable&lt;T&gt; source, T item) =&gt;
        Enumerable.Concat(source, new[] { item });
}


Updated Elapsed

What do you say about this one? Looks cleaner for me.

    public TimeSpan Elapsed =&gt; IsRunning ? NextElapsed : SameElapsed;
    TimeSpan SameElapsed =&gt; Interval.Current;
    TimeSpan NextElapsed =&gt; Interval.MoveNext() 
        ? Interval.Current 
        : throw new InvalidOperationException("You did not define enough timestamps.");