Invariant rule in Liskov Substitution Principle

From Liskov Substitution Principle, I am still not very clear about the invariant rule. I read through many posts but I still have doubts.

My example is picked from this blog, the example is slightly modified in this question to "simplify" the example for my onw understanding purposes, which eventually created the doubts. – from the blog in the section: "Invariants must be maintained" in the link.

From LSP: Invariant cannot be weakened in the subtype.

For an example:

public class ShippingStrategy
{
    private decimal _flatRate;
    public virtual decimal FlatRate
    {
        get { return _flatRate; }
        set
        {
            if (value <= decimal.Zero)
            {
                throw new ArgumentOutOfRangeException("value", "Flat rate must be positive and non - zero");
            }
            _flatRate = value;
        }
    }
}
public class AsiaPacificShippingStrategy : ShippingStrategy
{
    public override decimal FlatRate
    {
        get { return base.FlatRate; }
        set
        {
            if (value <= 10m) // m == decimal denotation for c#
            {
                throw new ArgumentOutOfRangeException("value", "Flat rate greater than 10");
            }
            base.FlatRate = value;
        }
    }
}
public class EuropeShippingStrategy : ShippingStrategy
{
    public override decimal FlatRate
    {
        get { return base.FlatRate; }
        set { base.FlatRate = value; }
    }
}
public class WorldWideShippingStrategy : ShippingStrategy
{
    private decimal _flatRate; // local field
    public override decimal FlatRate
    {
        get { return _flatRate; }
        set { _flatRate = value; }
    }
}

What have here is:

The parent, ShippingStrategy has a property call FlatRate and its condition is the value has to be greater than zero.

Now in the AsiaPacificShippingStrategy, it overrides the property and tightening the condition – I think that complies with LSP.

Now in EuropeShippingStrategy it is weakening the condition – which I feel like breaking LSP and same for WorldWideShippingStrategy, I guess.

I am not clear about a few things-

First, these all feels like the precondition rule to me. – but again FlatRate with its own condition makes itself as a candidate for encapsulation into its own type. So that distinguishes it from the precondition rule. Am I correct here?

The example in the post took a different approach to explain the invariant rule. The parent uses a constructor to set the value for flatRate and has the FlatRate as a protected member. Then method hiding is used in the child to override it.

Second, Well, I think we are achieving the same demonstration of invariant rule(?) but what I am unclear is that in the below example why parent class is only lettings to set the flatRate using a constructor and not directly by the property and so is FlatRate marked protected. Is there something that I am missing to understand?

public class ShippingStrategy
{
    private decimal flatRate;
    public ShippingStrategy(decimal flatRate)
    {
        if (flatRate <= decimal.Zero)
            throw new ArgumentOutOfRangeException("flatRate", "Flat rate must be positive and non - zero");
        this.flatRate = flatRate;
    }

    protected decimal FlatRate
    {
        get {return flatRate;}
        set
        {
            if (value <= decimal.Zero)
                throw new ArgumentOutOfRangeException("value", "Flat rate must be positive and non - zero");
            flatRate = value;
        }
    }
}

public class WorldWideShippingStrategy : ShippingStrategy
{
    public WorldWideShippingStrategy(decimal flatRate) : base(flatRate){}
    public new decimal FlatRate
    {
        get{return base.FlatRate; }
        set{base.FlatRate = value;}
    }
}