Unit testing an unspecific order of method calls
You're right, the way you're mocking the methods is tightly coupling the sequence of events, even though you don't really care about the order.  What you really care about is that given a list, both methods are called, with the input/outputs chained and the overall output is the list without the filtered items.  You can achieve this by rewriting your test:

public void Gets_No_Bad_Ranking_And_No_Low_Points()
{
    // Create three entities, one to be removed by each of the filter functions
    // and one to be left over, since checking for an empty list isn't conclusive
    var badEntity = Substitute.For&lt;MyEntity&gt;();
    var lowEntity = Substitute.For&lt;MyEntity&gt;();
    var remainingEntity = Substitute.For&lt;MyEntity&gt;();

    // put all of the created entities into the initial list
    var myEntities = new List&lt;MyEntity&gt;() { badEntity, lowEntity, remainingEntity };
    var myMethodClass = Substitute.For&lt;IMyMethodClass&gt;();
    var target = new MyTargetClass(myMethodClass);

    // When RemoveBadRanking is called, we match against any parameter of the correct type,
    // then we filter the supplied list to exclude the badEntity
    myMethodClass.RemoveBadRanking(Arg.Any&lt;IEnumerable&lt;MyEntity&gt;&gt;())
        .Returns(args =&gt; ((List&lt;MyEntity&gt;)args[0]).Where(e =&gt; e != badEntity).ToList());

    // Do the same thing, but for lowEntity
    myMethodClass.RemoveLowPoints(Arg.Any&lt;IEnumerable&lt;MyEntity&gt;&gt;())
        .Returns(args =&gt; ((List&lt;MyEntity&gt;)args[0]).Where(e =&gt; e != lowEntity).ToList());

    var filteredEntites = target.GetFilteredEntites(myEntities);

    // If both substitutes have been called, then the returned list should only
    // have the remainingEntity in it.
    Assert.AreEqual(1, filteredEntites.Count);
    Assert.AreSame(remainingEntity, filteredEntites.First());
}


Whether or not this is an improvement is a bit subjective... it's trading the added complexity of the test for the looser coupling.