
<p class="has-drop-cap">1Toulouse (första start kl. 13.50) är skådeplatsen när årets Prix d&#8217;Amerique-vinnare <strong>Hooker Berry</strong> (e. Booster Winner) gör sin andra start efter sju månaders tävlingsuppehåll.</p>



<p>Nicolas Bazire kör sexåringen i Grand Prix du Sud-Ouest (€180.000) där förutsättningarna är 2.750 meter autostart. Hooker Berry har spår längst ut bakom startbilsvingen och kamperar bland annat mot stallkamraten <strong>Elie de Beaufour</strong> (e. Royal Dream) samt Grand Prix Anjou-Maine-vinnaren <strong>Gaspar de Brion</strong> (e. Singalo).</p>



<p>Smaskiga 81.000 euro väntar vinnaren i detta lopp som alternerar mellan Agen, Beaumont, Bordeaux och Toulouse. </p>



<p>Tre svenskfödda hästar startar likaså under tävlingsdagen. Philippe Daugeards <strong>Staro Mojito</strong> (e. Make it Happen) syns i Quinté-loppet Grand Prix Dynavena (€35.000), Pierre Levesques <strong>Huis Clos</strong> (e. Bird Parker) testar lyckan i sadelloppet Prix de la Depeche du Midi (€35.000) och Johan Untersteiners <strong>Racing Ribb </strong>(e. Raja Mirchi) finns med i evakueringsloppet Grand Prix Baron d&#8217;Ardeuil Aoc Buzet (€35.000).</p>



<p><a href="https://sulkysport.se/trav-och-galopp/toulouse-2023-10-25/" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistor till tävlingarna i Toulouse.</a></p>



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



<p class="has-drop-cap">2Medan de tre- och fyraåriga hästarna har kvalat klart inom Breeders Crown och laddar för semifinalerna på Solvalla den 5 november, så rullar BC-loppen för tvååringar vidare på Åby ikväll. Där körs det tredje av totalt fyra lopp för 2021-årgången och en av de ungdomar som visat mest hittills dyker upp i startlistan.</p>



<p>Det handlar om Per Nordström-tränade <strong>Captiva</strong> (e. Walner), som slog in en kvarts miljon kronor i Sweden International Yearling Sales Auktionslopp i livets andra start där hon blev ”drömmilare” på 1.14,6a/1.640 meter. Förutom Captiva är det endast Anders Zackrissons <strong>Ebba Kuce </strong>(e. Who&#8217;s Who) som vunnit lopp av elva hästar i fältet.</p>



<h2 class="wp-block-heading">Vinnare av årets Breeders Crown-lopp för tvååringar:</h2>



<ul class="wp-block-list">
<li>Bergsåker 25 augusti: <strong>Duncan Cowan</strong> (e. Walner) – Erik Adielsson (Svante Båth) –1.16,7am</li>



<li>Solvalla 20 september: <strong>L&#8217;Amourpourblanca</strong> (e. Face Time Bourbon) – Rick Ebbinge – 1.16,4am</li>
</ul>



<p>175.000 kronor väntar vinnaren och 125.000 kronor i förstapris ligger i potten i ett annat unghästlopp på Åby. Det handlar om ett bonuslopp i Breeders Course-serien för treåringar som är stängt vid 100.000 kronor. Flera av deltagarna närmast tangerar den summan och fem av tolv har sprungit in 95.000 eller mer.</p>



<p>Geir Vegard Gundersen-tränade stoet <strong>Kanaka</strong> (e. Ready Cash) är en av dem och hittills har det blivit tre segrar på tio försök, fast dessa har tagits i Norge. Från fyra starter på svensk mark har hon gått segerlös. Kanske dags att bryta sviten den här gången?</p>



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



<p class="has-drop-cap">3Åby (start 18.27) delar kvällens expresstrav med Solvalla (start 18.15) och Breeders Course-loppet för treåringar tar plats på den stora spelkupongen.</p>



<p>På huvudstadsbanan handlar det om nya försök till Solvallaserien och en obesegrad men skadedrabbad femåring jagar sjunde raka triumfen. Timo Nurmos-tränade <strong>Isco Am </strong>(e. Father Patrick) vann sina två starter på hösten som treåring, innan han försvann i tio månader. Tre nya triumfer kom förra hösten, men sedan var det dags för nytt långt tävlingsuppehåll.</p>



<p>För tre veckor sedan var Isco Am tillbaka på tävlingsbanan och han gjorde som han brukar – och vann!</p>



<p>Är det raka spåret mot sjunde raka segern för Isco Am som blir tung favorit på V86? Sulkysports tips med viktiga punkter, spikar och favoriter i fara publiceras som vanligt klockan 12.00 idag.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/10/25v86.pdf" class="">Här kan du ta del av dagens startlistor till tävlingarna på Solvalla och Åby.</a></p>



<p><em>Vill du spela V86 tillsammans med Sulkysport kan du välja mellan följande alternativ:</em></p>



<p><a href="https://www.atg.se/andelskungen/spel/251721_V86_2023-10-25_40_1" class="">Sulkysport Lilla V86 – 15 andelar á 75 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206235_V86_2023-10-25_40_1" class="">Sulkysport Stora V86 – 15 andelar á 250 kr/styck</a></p>



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



<p class="has-drop-cap">4 Trefaldige Grupp I-vinnaren <strong>Fado du Chene</strong> (e. Singalo-Star du Chene), 1.11,1m/€967.400, gick ur tiden i måndags åtta år gammal. Montéspecialisten tog hem Prix de Vincennes (€240.000), Prix d’Essai (€200.000) och Saint-Leger des Trotteurs (€150.000) plus åtta semi-classique-löpningar.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2018/02/prixedouardmarcillac2-617x423.jpg" alt="" class="wp-image-18836"/><figcaption class="wp-element-caption">Fado du Chene tävlade framgångsrikt under Paul-Philippe Ploquin. Foto: Gerard Forni</figcaption></figure>



<p>– Fado var inte någon enkel häst, han var en krigsmaskin och full av liv. Karaktären av ett lejon, motorn i ett flygplan och skönhet av ett konstverk, sammanfattade ägaren Yvonne Guedj på ”24 au Trot.”</p>



<p>Hans mor <strong>Star du Chene</strong> (e. Coktail Jet), 1.14,7m/€70.670, vann fyra lopp varav ett på Vincennes. Förutom Fado du Chene har hon lämnat <strong>Geisha du Chene</strong> (e. Athos des Elfes), 1.15,5m/€24.040, och <strong>Diva du Chene</strong> (e. Nobody du Chene), 1.15,4am*/€20.590.</p>



<p>Fado du Chene klev in i aveln 2020 och första kullen innehåller 23 tvååringar, varav fem L-hästar varit ute och kvalat. Ifjol registrerades 39 hästar efter honom och i år 20 travare.</p>



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



<p class="has-drop-cap">5På söndag avgörs Gran Premio Delle Nazioni (€220.000) – Nationernas Pris i svenskmun – på La Maura-banan i Milano.</p>



<p>International Trot-vinnaren <strong>Vivid Wise As </strong>(e. Yankee Glide) är på jakt efter sin tredje raka seger i den Grupp I-klassade klassikern och skulle bli den förste någonsin att lyckas med den bedriften om han vinner söndagens lopp.</p>



<p>Elitloppstvåan<strong> Go On Boy</strong> (e. Password) finns med bland de åtta motståndarna liksom svenskfödde <strong>Usain Töll</strong> (e. Googoo Gaagaa).</p>



<p><strong>Startlista Gran Premio Delle Nazioni</strong><br><em>2.250 meter autostart, förstapris: 78.200 euro</em></p>



<ol class="wp-block-list">
<li>Charmant de Zack – Alessandro Gocciadoro</li>



<li>Heliade du Goutier – Giampaolo Minnucci</li>



<li>Vivid Wise As – Matthieu Abrivard</li>



<li>Capital Mail – Gabriele Gelormini</li>



<li>Cokstile – Vincenzo P.Dell&#8217;Annunziata</li>



<li>Usain Töll – Marco Volpato</li>



<li>Go On Boy – Romain Derieux</li>



<li>Chance Ek – Pietro Gubellini</li>



<li>City Lux – Riccardo Pezzatini</li>
</ol>



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



<p class="has-drop-cap">6Ett par lite dyrare hästar från Travera-auktionen har nu funnit nya tränare. Walner-dottern<strong> Paris Time Trot</strong>, 1.18,3m/6.500 kr som köptes av Krister Nilsson i Sigtuna för 470.000 kronor för två veckor sedan finns numera hos Henrik Larsson efter att tidigare funnits hos Svante Båth.</p>



<p>Från Åbys Maria Törnqvist till Bodenproffset Jaakko Alamäki har nu <strong>Sensitive Tile</strong> (e. Trixton) 1.13,9am/119.000 kr gjort resan efter att köpts av Skogqvist Olje &#038; Transport AB för 170.000 kronor.<br>Det treåriga stoet har inlett karriären med två segrar på åtta starter, men kommer närmast från plumpar i Oakskval samt i Oaks Consolation.</p>



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



<p class="has-drop-cap">7Efter att funnits som en Beta-version under ett fåtal månader så har nu Det Norske Travselskap släppt sin slutversion av sin nya hemsida.</p>



<p>Precis som tidigare är adressen travsport.no för att nå dit, men utseendet är tveklöst annorlunda och funktionerna desto fler på den sida som tidigare känts som en hemmasnickrad HTML-lösning anpassad för att kunna hantera trafik från besökare som suttit uppkopplade via modem i telefonjacket.</p>



<p><a href="https://www.travsport.no/" data-type="link" data-id="https://www.travsport.no/" target="_blank" rel="noreferrer noopener">Klicka här om du vill besöka DNT:s hemsida.</a></p>

Fokustema
Morgonsvepet
Läs senare
PDA-vinnaren i hetluften
Om Prix d'Amerique-vinnarens andra höststart i Toulouse, topptravare ur tiden, Breeders Crown-lopp på Åby samt auktionshästar som bytt regi går bland annat att läsa om i dagens morgonsvep.
