
<p class="has-drop-cap wp-block-paragraph">1 Laurent-Claude Abrivards <strong>Inexess Bleu</strong> (e. Vittel de Brevol), 1.10,3am*/€912.280, har inte startat sedan den 7 juni när han tog hem Prix Chambon P (€120.000) på Vincennes.</p>



<p class="wp-block-paragraph">Idag är han tillbaka på tävlingsbanan och jagar sin tionde raka seger i Grand Prix de la Federation Regionale du Nord (€120.000) i La Capelle. Sin segersvit inledde Inexess Bleu i Prix de Blois (€90.000) på den franska huvudstadsbanan den 5 december förra året.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/idaodetillardtdsop250126adamstromstalltz-617x416.jpg" alt="" class="wp-image-681986"/><figcaption class="wp-element-caption">Tränaren Thierry Duvaldestin, Idao de Tillard och skötaren Susanne Ohme efter Idao de Tillards seger i Prix d&#8217;Amérique. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Inexess Bleu kommer inte till dukat bord utan löpningen över 1.800 meter autostart innehåller många namnkunniga travare. Från Thierry Duvaldestins stall selas det ut tre hästar. <strong>Falco Killer Gar</strong> och <strong>Diamond Truppo</strong> körs av sönerna, medan pappa själv tar hand om <strong>Banderas Bi</strong>.</p>



<p class="wp-block-paragraph">Thierry Duvaldestin kör sparsamt med lopp numera, men hans facit är imponerande. På 44 starter i år har det blivit 25 segrar. Karriären innehåller totalt 1.738 segrar.</p>



<p class="wp-block-paragraph"><strong>Grand Prix de la Federation Regionale du Nord </strong>(€120.000)<br>4-11 år.<br><em>1.800 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Deus Zack</strong> (e. Victor Gio) – Gabriele Gelormini</li>



<li><strong>Inexess Bleu</strong> (e. Vittel de Brevol) – Alexandre Abrivard</li>



<li><strong>Justin Bold</strong> (e. Bold Eagle) – Pierre-Yves Verva</li>



<li><strong>Falco Killer Gar </strong>(e. Varenne) – Clément Duvaldestin</li>



<li><strong>Hulysse Digeo</strong> (e. Reve de Beylev) – Jean-William Hallais</li>



<li><strong>Elvis du Vallon</strong> (e. Reve de Beylev) – Franck Nivard</li>



<li><strong>Inmarosa</strong> (e. Amiral Sacha) – Léo Abrivard</li>



<li><strong>Banderas Bi</strong> (e. Ganymede) – Thierry Duvaldestin</li>



<li><strong>Diamond Truppo</strong> (e. Varenne) – Théo Duvaldestin</li>



<li><strong>Jango Vici</strong> (e. Dragon des Racques) – Florent Guerineau</li>



<li><strong>Happy Danica</strong> (e. Briac Dark) – Alexis Garandeau</li>



<li><strong>Kapaula de l’Epine</strong> (e. Discours Joyeux) – Thomas Beauchene</li>
</ol>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">2 I <strong>La Capelle </strong>(första start kl. 13.55) dyker tre svenskfödda travare – Jörgen Westholms <strong>Beat Generation </strong>(e. Bird Parker), <strong>Donizetti (</strong>e. Maharajah) och <strong>Mister Donald</strong> (e. Niky) – upp i det första loppet och 15.750 euro väntar vinnaren i Prix du Credit Agricole Nord-Est (€35.000) över 2.700 meter, autostart.</p>



<p class="wp-block-paragraph">Senare under dagen startar också svenskfödde och Thierry Duvaldestin-tränade <strong>Mister Invictus </strong>(e. Ready Cash) i sadelloppet Prix Francois Caille (€35.000) över 2.750 meter och han rids av Florian Desmigneux.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/la-capelle-2025-09-03/" data-type="link" data-id="https://sulkysport.se/trav-och-galopp/la-capelle-2025-09-03/" target="_blank" rel="noreferrer noopener">Här hittar ni startlistorna till La Capelles tävlingar.</a></p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">3 En annan av Laurent-Claude Abrivards toppvalacker – <strong>Nimrod Borealis</strong> (e. Arnaqueur-Hermine Diam), 1.11,8/€1.366.900 – har gått ur tiden vid 24 års ålder. Han avslutade sin karriär med fyra raka triumfer utomlands – Schweiz, Spanien, Tyskland och Belgien – och valacken vann totalt 19 lopp, varav tre Grupp II-vinster i Grand Prix du Sud-Ouest (€160.000), Grand National du Trot (€150.000) och Prix des Ducs de Normandie (€150.000).</p>



<p class="wp-block-paragraph">Laurent-Claude Abrivards valack deltog också i Elitloppet och slutade fyra i Elitloppet 2009. Nimrod Borealis deltog även 2010, men då slogs han ut i försöket. </p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/07/knoxvillemadm250701adamstromstalltz-617x393.jpg" alt="" class="wp-image-738538"/><figcaption class="wp-element-caption">Knoxville och Magnus A Djuse. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4För fem veckor sedan tog Timo Nurmos-tränade <strong>Knoxville</strong> (e. Nuncio) hem Sommarfavoriten på Solvalla. Ikväll (första start 18.15) kan treåringen fylla på med en ny prischeck på 200.000 kronor.</p>



<p class="wp-block-paragraph">Solvallas Kriterieserie byggdes 2023 ut med Höstfavoriten i två klasser, för hingstar/valacker respektive ston, som ytterligare ett större lopp i förberedelserna inför uttagningsloppen till banans flaggskepp för treåringarna, Kriteriet och Oaks. Uttagningsloppen till dessa lopp avgörs på Solvalla söndagen den 28 september.<br>Bland Knoxvilles motståndare i hingstarnas klass finns Fredrik Wallin-tränade <strong>Hiram</strong> (e. Maharajah) – trea i långa E3.</p>



<p class="wp-block-paragraph">I stoavdelningen finns också en finalist från långa E3: <strong>Global Genesis</strong> (e. Nuncio), som är tillbaka i Fredrik Wallins ägo och träning efter att ha sålts för 880.000 kronor på Travera inför E3-finalen. Annars dominerar Roger Walmann och Daniel Wäjersten numerärt – duon har tre hästar vardera.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">5Solvalla delar kvällens expresstrav med <strong>Axevalla</strong> (första start 18.27). Femårige <strong>Fashion Monger</strong> (e. Panne de Moteur) var femma i Breeders Crown-finalen som treåring, men efter en galoppfylld fyraåringssäsong bytte han Johan Untersteiners mot Maria Törnqvists stall. <br>Där blev det tre segrar på de fem första starterna i sommar – däribland Wången Cup-finalen inom V75 i Halmstad – men i senaste starten var hästen inte lika vass som sjua.<br>– Efter senaste starten fick han en liten välbehövlig paus, men är nu på gång igen. På papperet är det ett ganska bra lopp, men visst ska vår häst tillhöra de som ska räknas tidigt, säger Maria Törnqvist i Axevallas banprogram om en av kvällens stora favoriter på V86.</p>



<p class="wp-block-paragraph"><em>Hos Sulkysports samarbetspartner Simsalabim finns andelar till kvällens V86-omgång.</em><br><a href="https://www.atg.se/simsalabim/spel/293606_V86_2025-09-03_40_1" target="_blank" rel="noreferrer noopener">Här finns andel till V86 Rank &#038; Tips-systemet för 125 kr/st!</a></p>



<p class="wp-block-paragraph">På Axevalla körs också första försöket av sex i banans höstserie för treåringar med final den 9 december med 60.000 kronor i förstapris. </p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/09/03v86.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till onsdagens tävlingar.</a></p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">6 Från en auktion till en annan…igår hölls <a href="https://sulkysport.se/calgary-games-son-dyrast/" data-type="link" data-id="https://sulkysport.se/calgary-games-son-dyrast/" target="_blank" rel="noreferrer noopener">Select European Yearling Sale</a> i Deauville och idag slår Arqana Trot upp portarna för Ventes de Yearlings Sélectionnés i den franska badorten vid kusten i Normandie.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/colbertdamauktindeauvillekopia-617x411.jpg" alt="" class="wp-image-626466"/><figcaption class="wp-element-caption">Auktionshallen i Deauville. Foto: stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Under tre dagar ska nya ägare hittas till 469 franskfödda ettåringar. <a href="https://www.arqana-trot.com/catalogue/ventes-de-yearlings-2025/224" data-type="link" data-id="https://www.arqana-trot.com/catalogue/ventes-de-yearlings-2025/224" target="_blank" rel="noreferrer noopener">Här hittar ni listan över samtliga hästar som säljs.</a></p>



<p class="wp-block-paragraph">Hetaste avelshingstarna? <strong>Ready Cash </strong>och hans son <strong>Face Time Bourbon</strong>, som har 16 ettåringar vardera ute till försäljning.</p>



<p class="wp-block-paragraph">Det är på väg att bli vaktombyte i Frankrike och Ready Cash är förvisso fortsatt i topp när det gäller treåringar, men Face Time Bourbon är hack i häl.</p>



<p class="wp-block-paragraph">Så här ser tio-i-topp ut per den 31 augusti i Frankrike för avelshingstar, vars avkommor är fyllda tre år:</p>



<p class="wp-block-paragraph"><strong>Avelshingst – Prispengar (euro)</strong></p>



<ol class="wp-block-list">
<li>Ready Cash – €1.125.090</li>



<li>Face Time Bourbon – €1.112.785</li>



<li>Prodigious – €868.580</li>



<li>Love You – €727.065</li>



<li>Boccador de Simm – €667.405</li>



<li>Hohneck – €653.315</li>



<li>Helgafell – €647.745</li>



<li>Royal Dream – €672.760</li>



<li>Bird Parker – €521.710</li>



<li>Village Mystic – €454.035</li>
</ol>



<p class="wp-block-paragraph">Noteras kan också när det gäller alla åldrar så har Face Time Bourbon fortfarande en bit upp till Ready Cash. Den senare leder med 5.022.065 euro och Face Time Bourbon är tvåa med 3.846.580 euro. Bakom honom följer Booster Winner (€3.780.035), Love You (€3.489.155) och Prodigious (€3.087.940).</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">7 Claus Nielsen, tidigare sportchef och direktör för danska travförbundet, var inte alls nöjd med utfallet i Danskt Derby och Danskt Stoderby. Om det hade varit andra lopp än klassiska danska avelslopp, skulle folk ha jublat över de imponerande prestationerna från vinnarna av de två travderbyn under helgen, skriver Claus Nielsen i en insändare på travservice.dk.</p>



<p class="wp-block-paragraph"><em>”Vi sitter kvar med en bitter eftersmak när det visar sig att de två vinnarna är registrerade i Danmark eftersom de inte kunde registreras i Sverige”</em>, skriver Nielsen och fortsätter:</p>



<p class="wp-block-paragraph"><em>”Det är inte första gången vi ser liknande deltagare i ett danskt avelslopp, och det finns uppenbarligen många möjligheter för att detta ska hända igen under de kommande åren. Dansk Travsports Centralförbund bör omedelbart följa i Svensk Travsports fotspår och återinföra begreppet mockinländare.”</em></p>



<p class="wp-block-paragraph"><a href="https://travservice.dk/talerstolen-genindfoer-mockindlaender-begrebet/" data-type="link" data-id="https://travservice.dk/talerstolen-genindfoer-mockindlaender-begrebet/" target="_blank" rel="noreferrer noopener">Läs hela insändaren här.</a></p>
