Limite de herança?

Contexto: A partir de classes de um sistema, devo criar um XML para outro sistema o consumir.

Como cada parte do XML precisa ser alterado de diferentes formas, decidi então partir o código em várias classes especificas.

classe abstrata

abstract class UDFRequestField
{
    /**
     * @var UDFRequestField|null
     */
    private $nextUdf;

    /**
     * UDFRequestField constructor.
     * @param UDFRequestField|null $nextUdf
     */
    public function __construct(?UDFRequestField $nextUdf = null)
    {
        $this->nextUdf = $nextUdf;
    }

    abstract public function createSpecificXml($absence): ?string;

    public function generateXml($absence): string
    {
        return $this->createSpecificXml($absence).$this->createXmlForOtherNode($absence);
    }

    private function createXmlForOtherNode($absence): string
    {
        return $this->nextUdf === null ? "" : $this->nextUdf->createSpecificXml($absence);
    }
}

Cadeia dos casos

public function generate(Absence $absence): string
{
    $RequestAbsenceId = new RequestAbsenceId();
    $RequestFieldDate = new RequestFieldDate($RequestAbsenceId);
    $RequestFieldLanguage = new RequestFieldLanguage($RequestFieldDate);

    return $RequestFieldLanguage->generateXml($absence);
}

Cada uma das classes produz o seu formato de XML para o caso especifico.

Entretanto, quando executo o código, ele só faz a verificação de duas das classes da cadeia.. Será que estou esquecendo de algo? Ou existe algum limite nas configurações?

Primeiro tinha tentado o uso do Chain of Resposability mas vi que não era o melhor padrão para propagação de regras e achei este padrão mais adequado para fazer essas mudanças e criações.