
<p class="has-drop-cap">1 <strong>San Moteur</strong>, <strong>Etonnant</strong>, <strong>Horsy Dream</strong>, <strong>Galius</strong>, <strong>Face Time Bourbon</strong> och <strong>Jushua Tree</strong>. Den gemensamma nämnaren för alla dessa topphästar? Bortfall ur Prix d’Amérique-diskussionen mitt under brinnande vintermeeting i Paris under de senaste åren och tyvärr ser det ut att bli ett liknande fall även i 2026 års upplaga av det stora slaget.</p>



<p>För att <strong>Idao de Tillard</strong> (e. Severino) ska resa sig efter bukoperation och hinnas sättas i ordning till något av de större loppen under meetinget på Vincennes känns i princip helt uteslutet. </p>



<p><a href="https://www.paris-turf.com/actualites/amerique-races/actualite-idao-de-tillard-et-maintenant-301700841599" target="_blank" rel="noreferrer noopener">Paris-Turf</a> behandlade frågan igår, torsdag och kom till slutsatsen att även om Idao de Tillard skulle kunna rehabiliteras i kvick fart, så innebär en operation ändå en viss tids konvalescens och kretsen kring den dubble Prix d’Amérique-mästaren är inte känd för att skynda med hästar som inte håller full form. </p>



<p>Alltså, chansen att Idao de Tillard försvarar sin titel i januari är i princip noll, han hinner inte bli klar.</p>



<figure class="wp-block-image alignright size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2024/01/prixboldeagle3-617x411.jpg" alt="" class="wp-image-546496" style="width:403px;height:auto"/><figcaption class="wp-element-caption">Jushua Tree. Foto Gerard Forni.</figcaption></figure>



<p>Ifjol trodde många att <strong>Jushua Tree</strong> skulle bli vinnare av PdA 2025, men han föll ifrån och detsamma gällde dominanten <strong>Horsy Dream</strong>, som under 2024 visade sig vara Europas främste travare i och med segrarna i Elitloppet och Åby World Grand Prix.</p>



<p>Prix d’Amérique öppnas upp för många kandidater i och med Idao de Tillards troliga frånvaro. <strong>Josh Power</strong> imponerade stort i Prix de Bretagne förra helgen, <strong>Borups Victory</strong> likaså och helt klart innebär förhandsfavoritens bortfall att svensklägret har en stark kandidat att hålla på. Det är drygt två månader kvar, men spekulationerna blir hetare för varje vecka vi närmar oss vinterns höjdpunkt och som Paris-Turf säger: Yngre hästar som <strong>Lovino Bello</strong> och <strong>Frank Gio</strong> kan tänkas våga ta chansen, precis som en viss <strong>Francesco Zet</strong>…</p>



<p>Josh Powers tränare och kusk, <strong>Sébastien Ernault</strong>, sammanfattade Idao de Tillards troliga frånvaro så här:<br>– Ärligt talat är jag besviken för sportens skull och för hela kretsen runt Idao de Tillard. Det är verkligen synd. Man önskar inte sådana problem ens sin direkta och hårdaste konkurrent. Med tanke på hans upplopp i finalen av UET Elite Circuit på Solvalla såg Idao de Tillard än en gång ut att bli favorit i Prix d’Amérique.</p>



<p>Än är det inte helt kört, men chansen att Idao de Tillard kommer till start i Prix d’Amérique är minimal. </p>



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



<p class="has-drop-cap">2 Ikväll är det dags för senhöstens första E3-revansch av tre och tio hästar gör upp om 150.000 kronor i förstapris på Romme (första start 18.20). Flera storloppsmeriterade hästar dyker upp i startlistan bland de tio hingstar och valacker som anmäldes.</p>



<p>En av dem tävlade så sent som i lördags i Breeders Crown-finalen, dit Claes Sjöström kvalat in <strong>Olle Sting</strong> (e. Don Fanucci Zet). Denne slutade dock oplacerad i finalen.</p>



<p>Två finalister från Svenskt Travkriterium finns också med i E3-revanschen och både Daniel Redéns <strong>Javier Zet</strong> (e. Don Fanucci Zet) och Hans R Strömbergs <strong>Ruffel</strong> (e. Power) tog en del av priskakan i Kriteriet som femma och sexa.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/03/12ollesting1-617x333.jpg" alt="" class="wp-image-700826" style="width:677px;height:auto"/><figcaption class="wp-element-caption">Claes Sjöström höjde högernäven i luften när Olle Sting vann Margaretas Tidiga Unghästserie i mars. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Segermaskinen i fältet har bara testats en gång i årgångssammanhang. Det handlar om Gävleamatören Tiffany Wistrands valack <strong>Emporio Broline</strong> (e. Power), som var obesegrad när han slutade trea i Kriteriet consolation i början av oktober. Totalt har det blivit sex vinster på åtta försök och enda gången han missade pallen var i rikstotodebuten på Romme för tre veckor sedan där det blev en fjärdeplats.</p>



<p>E3-revanschen för ston över medeldistans avgörs på Färjestad den 30 november, medan den sista är öppen för båda könen i Kalmar den 5 december.</p>



<p>På Romme bjuds i övrigt ett fint tvååringslopp, där fyra av deltagarna vunnit lopp och Jasmine Isings <strong>Ismenis</strong> (e. Calgary Games) och Tomas Petterssons <strong>First Cookie Dream</strong> (e. Kadett C.D.) dessutom är obesegrade. Övriga vinnare i fältet är Claes Sjöströms<strong> Icy Conditions</strong> (e. Calgary Games) och Fredrik Wallin-tränade <strong>Global Holy Water</strong> (e. Calgary Games).</p>



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



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/07/batotosen2-617x333.jpg" alt="" class="wp-image-746366" style="width:677px;height:auto"/><figcaption class="wp-element-caption">Bato Tösen och Stefan Edin. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">3 Romme delar kvällens expresstrav och V64-kupong med Östersund (första start 18.30). I sjätte av åtta försök till dubbelcupens final i just Östersund på luciadagen den 13 december avgörs ikväll. Hela 200.000 kronor ligger i potten i finalen öppen enbart för ston på flera volter över medeldistans.</p>



<p>En av kvällens deltagare har redan vunnit försök och är given i finalen – och det är ett sto som gjort en annorlunda resa. Stefan Edin-tränade <strong>Bato Tösen</strong> (e. Bork Odin) är nämligen redan mamma!</p>



<p>Som treåring tillhörde hon de allra bästa stona i kullen med andraplatsen i Kriteriestoet bakom <strong>Dunungen</strong> (e. Smedheim Solan) som främsta merit. Som vann hon Derbystokval, men fungerade inte i finalen, där hon gick över i passgång. I slutet av det året blev hon gaffelbandsskadad, betäcktes som femåring och födde ifjol sonen <strong>B.T.Brage</strong> (e. Lome Brage).</p>



<p>En karriär som fölsto för gott? Det ville inte Bato Tösen! I somras var hon tillbaka på tävlingsbanan och det slutade med seger i första starten sedan november 2022. Efter två ”nollor” blev det seger igen i Bollnäs för knappt två veckor sedan i ett försök i dubbelcupen.</p>



<p>Ikväll kan hon ta andra raka, men kommer till allt annat än dukat bord i ett lopp med flera starka ston på jakt efter finalbiljetter. Som segervana duon<strong> Alm Vinni</strong> (e. Kleppe Fanden) och <strong>Tekno Britta</strong> (e. Tekno Odin) 20 meter före på startfållan i sprinterloppet. En annan motståndare är <strong>Bato Odina</strong> – storasyster och stallkamrat till Bato Tösen. </p>



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



<p class="has-drop-cap">4 Sex spårtrappor från en delningsproposition för hästar upp till 600.000 kronor intjänat utgör merparten av dagens lopp på lunchbanan Halmstad (start 12.20), men dagens höjdare kan bli ett treåringslopp med flera spännande namn.</p>



<p>Per Nordström-tränade <strong>Call Out My Name </strong>(e. Father Patrick) var sent igång och debuterade i mitten av september, sedan han köpts till Nordströms stall på våren som tvååring. Efter två inledande pallplatser har Call Out My Name plockat två raka segrar och Nordström jämför gärna med Kentucky River (7,1 miljoner på kontot), som han tävlade med som fyra- och femåring.</p>



<p>Nu ställs han bland annat mot en dansktränad trio i <strong>Mack One</strong> (e. Trixton), <strong>Lifestyle</strong> (e. Chocolatier) och <strong>Lookebie Diamond</strong> (e. Who’s Who), där de två förstnämnda vunnit tre lopp hittills.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/11/251121.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till torsdagens tävlingar. </a></p>



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



<p class="has-drop-cap">5 Vincennes kvällstävlingar idag inkluderas av femåringsloppet Prix Florentina (€41.000) där Björn Goops <strong>Kezio Josselyn</strong> (e. Brillantissime) är på jakt efter årets femte seger på fransk mark.</p>



<p>Matthieu Abrivard sitter upp bakom Goops valack som ännu inte varit lyckosam i Paris efter fem starter, varav fyra gjorda på Vincennes. Det finns goda möjligheter för ändring på det ikväll.</p>



<p>Thierry Duvaldestins segermaskin <strong>Kueen’s Pride </strong>(e. Prodigious) med tolv segrar på 19 starter lär bli svårstoppad i Prix Ostara (€53.000) för femåriga ston och i Prix Hermantaria (€62.000) för treåringar gör Face Time Bourbons lillebror <strong>Machiavel Bourbon</strong> (e. Prodigious-Vita Bourbon) debut på Vincennes. Hästen har fyra segrar på sex starter så här långt och nu kommer alltså första starten i huvudstaden för Jean-Philippe Monclins travare.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2024/07/clementthierryduvaldestin-617x333.jpg" alt="" class="wp-image-604189" style="width:677px;height:auto"/><figcaption class="wp-element-caption">Clement och Thierry Duvaldestin. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Första segern på Vincennes jagar samtliga av deltagarna i kvällens tvååringslopp. Fem av de tio hästarna i loppet har segrat, men ingen av dem är tagna i Paris. Thierry Duvaldestins hemmabygge <strong>Nespera</strong> (e. In The Money) är den ende av tvååringarna som hunnit med att vinna två gånger i karriären.</p>



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



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2022/10/periculumbsm221001adamstromstalltz-617x401.jpg" alt="" class="wp-image-361898" style="width:677px;height:auto"/><figcaption class="wp-element-caption">Periculum och Brian Sears vid seger på Red Mile som treåring. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">6 Stall Zets <strong>Periculum</strong> (e. Muscle Hill) har haft ett enastående år på tävlingsbanan i Amerika och Marcus Melanders skyddsling har tjänat 838.902 USD under säsongen. I kväll ställs han mot enklare motstånd än vanligt när MGM Grand Prix Trotting Series avgörs på 800-metersbanan Yonkers i New York. Scott Zeron sitter som vanligt upp bakom sexåringen och motstånd kommer från både Åke Svanstedts och Per Engbloms stall.</p>



<p>Svanstedt selar ut <strong>Khaosan Road </strong>(e. International Moni) medan Engblom mönstrar <strong>Cecil Hanover</strong> (e. Chapter Seven).</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2020/03/ultionfacevarv-617x247.jpg" alt="" class="wp-image-78294" style="width:677px;height:auto"/><figcaption class="wp-element-caption">Ultion Face och Adrian Kolgjini. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Per Engblom har även <strong>Ultion Face</strong> (e. Joke Face) med i ett av de andra två loppen ingående i MGM Grand Prix Trotting Series och där möter han en annan svenskfödd travare, <strong>Antognoni</strong> (e. Father Patrick), ägd och körd av Yannick Gingras.</p>



<h2 class="wp-block-heading">Startlista MGM GP ($50.000) 1</h2>



<p>Häst (far) – Tränare</p>



<ol class="wp-block-list">
<li>Antognoni (e. Father Patrick) – Ron Burke</li>



<li>Big Box Hanover (e. Uncle Peter) – Larry Stalbaum</li>



<li>Ultion Face (e. Joke Face) – Per Engblom</li>



<li>Sir Pinocchio (e. Met’s Hall) – Edward Hart</li>



<li>Keg Stand (e. Bar Hopping) – Nicholas Devita</li>



<li>Escaper (e. Muscle Hill) – Maria Alvarez</li>



<li>Dribbling Bi (e. Cantab Hall) – Ron Coyne Jr</li>



<li>Amigo Volo (e. Father Patrick) – Nifty Norman</li>
</ol>



<h2 class="wp-block-heading">Startlista MGM GP ($50.000) 2</h2>



<p>Häst (far) – Tränare</p>



<ol class="wp-block-list">
<li>Asteroid (e. Creatine) – Jeff Cullipher</li>



<li>Blackhawk Zette (e. Cantab Hall) – Robert Baggit Jr</li>



<li>Periculum (e. Muscle Hill) – Marcus Melander</li>



<li>Queen Of All (e. Swan For All) – Lance Hudson</li>



<li>Ari Ferrari J (e. Walner) – Tony Alagna</li>



<li>Khaosan Road (e. International Moni) – Åke Svanstedt</li>



<li>Cecil Hanover (e. Chapter Seven) – Per Engblom</li>



<li>Hot Flash Kimmy (e. Lookslikeachpndale) – Cory Stratton</li>
</ol>



<h2 class="wp-block-heading">Startlista MGM GP ($50.000) 3</h2>



<p>Häst (far) – Tränare</p>



<ol class="wp-block-list">
<li>Dire Straits (e. Muscle Hill) – Linda Toscano</li>



<li>Benny J (e. Walner) – Tony Alagna</li>



<li>Mississippi Storm (e. Cantab Hall) – Tom Fanning</li>



<li>Take All Comers (e. Creatine) – Jim Campbell</li>



<li>Security Protected (e. Father Patrick) – Cory Stratton</li>



<li>Oliver The Great (e. Bar Hopping) – Robert Baggit Jr</li>



<li>Southwind Coors (e. Walner) – Ron Burke</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/11/ontonorway112425deangillette1024-617x347.jpg" alt="" class="wp-image-793285" style="width:677px;height:auto"/><figcaption class="wp-element-caption">On To Norway. Foto: Dean Gillette</figcaption></figure>



<p class="has-drop-cap">7 Följetongen <strong>On To Norway</strong> (e. Muscle Massive) startar på i hemstaten Indiana och ikväll är det dags igen. Jakten på den 22:a raka segern i år sker på Hoosier Park i Indiana och som vanligt är det John De Long som styr treåringen som tränas av Ron Burke.</p>



<p>The Bally’s Randy ($49.200) körs för både hingstar och valacker, samt för ston och sju konkurrenter vågar sig på ett försök att sätta käppar i hjulet för Burkes segermaskin.</p>



<p>I stonas avdelning av The Bally’s Randy ($47.700) blir Steve Carters<strong> Divine Thing</strong> (e. Greenshoe) den stora favoriten i händerna på Trace Tetrick.</p>



<h2 class="wp-block-heading">Startlista The Bally’s Randy för ston</h2>



<p>Häst (far) – Tränare</p>



<ol class="wp-block-list">
<li>Divine Thing (e. Greenshoe) – Steve Carter</li>



<li>Dreams Come Easy (e. Readly Express) – Brendan Johnson</li>



<li>Sweetasmoni (e. Dover Dan) – Ken Rucker</li>



<li>Swoop (e. Walner) – Steve Carter</li>



<li>Aunt Laura (e. Uncle Peter) – Virgill Morgan Jr</li>



<li>Mega Money (e. Triumphant Caviar) – Chris Beaver</li>



<li>Better Tak’em (e. Don’t Let’em) – Henry Graber Jr</li>



<li>A Milion Dances (e. Dover Dan) – Steve Carter</li>



<li>Fifty To Win (e. Fiftydallarbill) – Erv Miller</li>



<li>Made Of Dreams (Chapter Seven) – Melissa Essig</li>
</ol>



<h2 class="wp-block-heading">Startlista The Bally’s Randy, hingstar och valacker</h2>



<p>Häst (far) – Tränare</p>



<ol class="wp-block-list">
<li>Karinchak (e. Chapter Seven) – Ryan Miller</li>



<li>Give Me A Yankee (e. Bar Hopping) – Britney Dillon</li>



<li>Siesta Sandman (e. Don’t Let’em) – Tyler George</li>



<li>Gimpanzee Dancer (e. Gimpanzee) – Chris Beaver</li>



<li>On To Norway (e. Muscle Massive) – Ron Burke</li>



<li>Operator (e. You Know You Do) – Jay Hochstetler</li>



<li>Big Shoes (e. Greenshoe) – Ron Burke</li>



<li>Boots N Beer (e. Greenshoe) – Joe Putnam</li>
</ol>

Fokustema
Sju nyheter vid sju
Läs senare
Knapp chans för Idao de Tillard
Det ser mörkt ut för Idao de Tillard, åtminstone sett till hans chanser att vinna Prix d'Amérique tre år i rad.
E3-revansch på Romme.
Toppstammat på Vincennes i kväll.
Stjärnor i New York och i Indiana.
Här är dagens morgonnyheter.
