IEnumerable<T> Skip on unlimited sequence

Skip(n) doesn't access Current, it just calls MoveNext() n times.

So you need to perform the increment in MoveNext(), which is the logical place for that operation anyway:

Current does not move the position of the enumerator, and consecutive calls to Current return the same object until either MoveNext or Reset is called.

CodeCaster's answer is spot on - I'd just like to point out that you don't really need to implement your own enumerable for something like this:

public IEnumerable<BigInteger> FibonacciSequence()
{
  var previous = BigInteger.One;
  var current = BigInteger.Zero;

  while (true)
  {
    yield return current;

    var temp = current;
    current += previous;
    previous = temp;
  }
}

The compiler will create both the enumerator and the enumerable for you. For a simple enumerable like this the difference isn't really all that big (you just avoid tons of boilerplate), but if you actually need something more complicated than a simple recursive function, it makes a huge difference.

Move your logic into MoveNext:

public bool MoveNext() 
{
    var temp = _current;
     _current += _previous;
     _previous = temp;
    return true;
}

public void Reset()
{
    _previous = 1;
    _current = 0;
}

public BigInteger Current
{
    get
    {
        return _current;
    }
}

Skip(10) is simply calling MoveNext 10 times, and then Current. It also makes more logical sense to have the operation done in MoveNext, rather than current.