New Post: FluentValidation, Fody Validar and WPF....nested validation

Hello,
I'm new to Fluent Validation, I've discovered it using Fody's plugin Validar to validate a model under WPF. It almost works fine and it matches almost all of my needs. I've got a question that I think it's related to FluentValidation
consider this model

    [InjectValidation]
    [ImplementPropertyChanged]
    public class DealSpot : DealBase
    {
        #region Properties
        public Split Split { get; set; }

        private int segno;
        public int Segno
        {
            get
            {
                return segno;
            }
            set
            {
                segno = value;
                OnPropertyChanged("Segno");
                OnPropertyChanged("QtaDiv1");
            }
        }

        private double? cambio;
        public double? Cambio
        {
            get
            {
                return cambio;
            }
            set
            {
                cambio = value;
                OnPropertyChanged("Cambio");
            }
        }

        private double? qtaDiv1;
        public double? QtaDiv1
        {
            get
            {
                return qtaDiv1;
            }
            set
            {
                qtaDiv1 = value;
                OnPropertyChanged("QtaDiv1");
                OnPropertyChanged("QtaDiv2");
            }
        }

        private double? qtaDiv2;
        public double? QtaDiv2
        {
            get
            {
                return qtaDiv2;
            }
            set
            {
                qtaDiv2 = value;
                OnPropertyChanged("QtaDiv2");
            }
        }
        #endregion

        #region Ctor
        public DealSpot()
        {
            Split = new Split();
            Instrument = new Instrument();
        }
        #endregion

        #region Operators
        public static explicit operator DealSpot(DealInternal source)
        {
            DealSpot result = new DealSpot();

            result.Cambio = source.Cambio;
            result.Data = source.Data;
            result.DataValuta = source.DataValuta;
            result.Id = source.Id;
            result.IdCtp = source.IdCtp;
            result.IdIstituto = source.IdIstituto;
            result.IdPortafoglio = source.IdPortafoglio;
            result.IdStato = source.IdStato;
            result.Instrument = (Instrument)source.Instrument.Clone();
            result.Ora = source.Ora;
            result.QtaDiv1 = source.QtaDiv1;
            result.QtaDiv2 = source.QtaDiv2;
            result.Segno = source.Segno;
            result.Split = (Split)source.Split.Clone();
            result.Type = source.Type;

            return result;
        }
        #endregion

        #region IClonable
        public override object Clone()
        {
            var result = new DealSpot();

            result.Cambio = this.Cambio;
            result.CTP = this.CTP;
            result.Data = this.Data;
            result.DataValuta = this.DataValuta;
            result.Id = this.Id;
            result.IdCtp = this.IdCtp;
            result.IdIstituto = this.IdIstituto;
            result.IdPortafoglio = this.IdPortafoglio;
            result.IdStato = this.IdStato;
            result.Instrument = (Instrument)this.Instrument.Clone();
            result.Istituto = this.Istituto;
            result.Ora = this.Ora;
            result.Portfolio = this.Portfolio;
            result.QtaDiv1 = this.QtaDiv1;
            result.QtaDiv2 = this.QtaDiv2;
            result.Segno = this.Segno;
            result.Split = (Split)this.Split.Clone();
            result.Stato = this.Stato;
            result.Type = this.Type;

            return result;
        }
        #endregion

    }

    public class DealSpotValidator : AbstractValidator<DealSpot>
    {
        public DealSpotValidator()
        {
            RuleFor(x => x.Split).SetValidator(new SplitValidator());

            RuleFor(x => x.Cambio).GreaterThan(0).WithMessage(DealResources.STR_VALIDATION_CAMBIO);

            RuleFor(x => x.QtaDiv1).LessThan(0).When(x => x.Segno == 1).WithMessage(DealResources.STR_VALIDATION_NEGATIVE_QTA1);
            RuleFor(x => x.QtaDiv1).GreaterThanOrEqualTo(0).When(x => x.Segno == 0).WithMessage(DealResources.STR_VALIDATION_POSITIVE_QTA1);

            RuleFor(x => x.QtaDiv2).LessThan(0).When(x => x.QtaDiv1 > 0).WithMessage(DealResources.STR_VALIDATION_OPPOSITE_QTA2);
            RuleFor(x => x.QtaDiv2).GreaterThan(0).When(x => x.QtaDiv1 < 0).WithMessage(DealResources.STR_VALIDATION_OPPOSITE_QTA2);
        }
    }

//Split definition
 [InjectValidation]
    [ImplementPropertyChanged]
    public partial class Split : ICloneable,INotifyPropertyChanged
    {
        public int? Currency { get; set; }
        private double? fx;
        public double? Fx
        {
            get
            {
                return fx;
            }
            set
            {
                fx = value;
            }
        }

        public object Clone()
        {
            var result = new Split
               {
                   Currency = this.Currency,
                   Fx = this.Fx,
                   CurrencyDescr = this.CurrencyDescr
               };
            return result;
        }

        public event PropertyChangedEventHandler PropertyChanged;
    }

    public class SplitValidator : AbstractValidator<Split>
    {
        public SplitValidator()
        {
            RuleFor(x => x.Fx).GreaterThan(0).WithMessage("Il valore di cambio deve essere maggiore di zero");
        }

        public override FluentValidation.Results.ValidationResult Validate(Split instance)
        {
            return base.Validate(instance);
        }
    }

I thought that the validation would throw an error itself if its attached validator has error