
<p class="has-drop-cap">1Fjolårets Elitloppsvinnare <strong>Etonnant</strong> (e. Timoko) gör idag sin första start i karriären i tränaren Richard Westerinks födelseland Holland.</p>



<p>Den nioårige Timoko-sonen kommer till start i Grupp II-klassade Prijs der Giganten (€70.000) på Victoria Park-banan i Wolvega (första start kl. 15.30) där 35.000 euro väntar vinnaren.</p>



<p>För Etonnant blir detta hans första start sedan bottennappet i International Trot på Yonkers Raceway i New York och han &#8221;går upp i ringen&#8221; mot en svensktränad häst i form av Johan Untersteiners <strong>Heart of Steel</strong> (e. Cantab Hall) som körs av Peter Untersteiner.</p>



<p>Svenskfödde <strong>Hierro Boko </strong>(e. From Above) körs av Santtu Raitala från ett passande tredjespår och på sin utsida har han Alessandro Gocciadoros <strong>Zeudi Amg </strong>(e. Ideale Luis) som får Halmstadlicenserade Rick Ebbinge som kusk denna kväll.</p>



<p><strong>Startlista Prijs der Giganten</strong><br><em>2.100 meter autostart, förstapris: 35.000 euro</em></p>



<ol class="wp-block-list">
<li>Heart of Steel – Peter Untersteiner (Johan Untersteiner)</li>



<li>Carloforte Steel – Jaap van Rijn (Jeroen Engwerda)</li>



<li>Hierro Boko – Santtu Raitala (Hannu Korpi)</li>



<li>Zeudi Amg – Rick Ebbinge (Alessandro Gocciadoro)</li>



<li>Cash du Rib – Jean Loic Dersoir</li>



<li>Mister F Daag – Robin Bakker (Paul Hagoort)</li>



<li>Ideal du Rocher – Charley Mottier</li>



<li>Etonnant – Anthony Barrier (Richard Westerink)</li>



<li>Kimberly&#8217;s Wish – Hanna Huygens (Bas Crebas)</li>



<li>King Schermer – Michel Rothengatter</li>
</ol>



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



<p class="has-drop-cap">2Niels Jan Koster är en av de allra största i dansk travsport, kanske den allra störste? Han föddes i Holland 1887 och började i tonåring en karriär i travsporten i hemlandet. Som 25-åring gick flyttlasset till Danmark och Kosters meritlista är enorm. Eller vad sägs om tio Derbysegrar, fem Kriteriesegrar, sju Uppfödningsloppvinster och sex danska mästerskap?</p>



<p>Niels Jan Koster avled 1969 och året efter avgjordes premiärupplagan av N.J. Koster Memorial, ett snabblopp för äldre hästar på danska huvudstadsbanan Charlottenlund.</p>



<p>Förra året vann Flemming Jensen-tränade <strong>Emoji</strong> (e. Broad Bahn) tillsammans med Birger Jörgensen och eftermiddag är det dags för årets upplaga. Titelförsvararen finns med bakom startbilen igen och den här gången är det tränare Jensen som sitter i sulkyn.</p>



<p>Emoji ställs mot en armada från Bo Westergårds stall bestående av kvartetten <strong>Get A Wish</strong> (e. Wishing Stone), <strong>Zaffiro Jet </strong>(e. Wishing Stone), <strong>Floris Baldwin </strong>(e. Passing Renka) och<strong> Stonefire U.S. </strong>(e. Wishing Stone).</p>



<p>De svenska hoppen är Håkan k Perssons<strong> Four Guys Dream</strong> (e. Dram Vacation), som drog innerspår, Fredrik Perssons<strong> Deborah S.H. </strong>(e. Maharajah) och Torbjörn Simbergs <strong>Osterc</strong> (e. Cantab Hall).</p>



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



<p class="has-drop-cap">3362 av 366 dagar skottåret 2024 är det travtävlingar på svensk mark. Fyra dagar är det däremot helt travfritt. En av dessa är motsvarande dagens tävlingar på danska Charlottenlund som nästa år sker den 10 november.</p>



<p>Ytterligare två söndagar sker utan svenska tävlingar, samt julafton där det inte några tävlingar är inplanerade nästa år. Så var det inte tänkt i år heller, men Eskilstuna bjuder in till förmiddagstävlingar för B-tränade hästar med 20.000-975.000 kronor intjänat och kuskar med högst 150 körda lopp förra året. Fem lopp med tolv hästar i varje som spårtrappor ska det bjudas på i Eskilstuna innan det är dags för Kalle Anka.</p>



<p><strong><em>Travfria dagar i Sverige 2024:</em></strong></p>



<ul class="wp-block-list">
<li>16 mars – Unionstravet, Bjerke</li>



<li>5 maj – Finlandia-Ajo, Vermo</li>



<li>10 november – N.J. Koster Memorial, Charlottenlund</li>



<li>24 december – julafton</li>
</ul>



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



<p class="has-drop-cap">4I avsaknad av tävlingar i Sverige är det en hel del svenskar som reser över sundet till Charlottenlund (första start 13.45). Förutom ovan nämnda trio i storloppet  N.J. Koster Memorial plockar bland annat Johan Untersteiner ut treårige <strong>Steady King </strong>(e. S.J.’s Caviar) i ett treåringslopp.</p>



<p>Sonen till 2016 års svenska stomästarinna <strong>Jetset</strong> (e. Juliano Star), 1.12,0am/2.464.830 kr, som tränades av Peter Untersteiner, inledde på bästa sätt i somras med tre raka segrar, varav två på 1.12-tider i Tingsryd. Efter uppehåll var han tillbaka i Breeders Crown-försök på Axevalla i oktober där det dock blev tidig galopp.</p>



<p>Nu ställs Steady King mot fyra svenskfödda travare i sexhästarsfältet, däribland Steen Juuls efter tre starter obesegrade <strong>Vamos Flax</strong> (e. Infinitif). En annan motståndare är Nuncio-dottern <strong>Foreign Affair</strong>, som vunnit fem lopp i år, men galopperade bort sig i Oakskvalet på Solvalla.</p>



<p>Thomas Uhrberg mönstrar<strong> Isseymiyake Secret </strong>(e. Ens Snapshot), som anslöt till Jägersrotränaren i början av sommaren och gjort goda resultat med bland annat finalplats i danska Kriteriet för en dryg månad sedan.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/11/12gs75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till söndagens tävlingar.</a></p>



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



<p class="has-drop-cap">5Alessandro Gocciadoro har räknat hem fyra av de sex senaste upplagorna av höstklassikern Gran Premio Palio Dei Comuni (€154.000) i Montegiorgio och har det väl förspänt även i årets lopp.</p>



<p><strong>Jimmy Ferro B.R.</strong> (e. Love You), <strong>Synergy</strong> (e. Father Patrick),<strong> Bonneville Gifont</strong> (e. Varenne), <strong>Always Ek</strong> (e. Filipp Roc) och <strong>Cointreau</strong> (e. Nad Al Sheba) är hans bidrag i loppet som avgörs via försök och final.</p>



<figure class="wp-block-image alignright size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/12/usaintoll1-617x354.jpg" alt="" class="wp-image-252127"/><figcaption class="wp-element-caption">Usain Töll vid seger på Vincennes. Idag jagar han Grupp I-vinst i italienska Montegiorgio. Foto: Gerard Forni</figcaption></figure>



<p>Mattia Orlando-tränade duon <strong>Usain Töll </strong>(e. Googoo Gaagaa) och <strong>Cabasse</strong> (e. Readly Express) är loppets två svenskfödda bidrag i detta lopp där Global Trustworthy (e. Muscle Hill) är den senaste svenskfödda hästen som vunnit finalen då han slog till år 2021.</p>



<p><a href="https://ippica.snai.it/partenti/T/IT32/2023-11-12?signature=3d06c54fa2b78e2d366df91906c29eeca8e47aeb0fe624201dd118a8b3517e89" data-type="link" data-id="https://ippica.snai.it/partenti/T/IT32/2023-11-12?signature=3d06c54fa2b78e2d366df91906c29eeca8e47aeb0fe624201dd118a8b3517e89" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna i Montegiorgio.</a></p>



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



<p class="has-drop-cap">6Mauquenchy (första start kl. 16.11) är den enda bana som arrangerar tävlingar med premiumstatus på fransk mark denna söndag och det finns två svensktränade hästar med i startlistorna.</p>



<p>Jörgen Westholms <strong>Holster</strong> (e. Bird Parker) kommer till start i Prix du Dou Lacroix (€25.000) i lag med Franck Ouvrie och så svingar sig Ann Kristin Rasmussen upp bakom Ron Kuipers<strong> Happy Boy</strong> (e. Coktail Jet) i amatörloppet Prix Carrefour Les Grandes Ventes (€6.000).</p>



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



<p class="has-drop-cap">7Föga oväntat blev det seger för fjolårets Sweden Cup-vinnare <strong>Bepi Bi </strong>(e. Donato Hanover) i lördagens stora amatörlopp Premio Federnat (€30.470).</p>



<p>Maurizio Biasuzzi styrde in den av Alessandro Gocciadoro-tränade sexåringen vinst i såväl försök som final där han gick som snabbast i avgörandets stund; 1.11,8a/1.600 meter.</p>



<p>Loppet avgjordes i Follonica och närmast följande var Ziguli dei Greppi (e. Uronometro) på 1.11,9 samt Bananarama Jet (e. Ken Warkentin) på 1.12,1.</p>

Fokustema
Morgonsvepet
Läs senare
Svenskar utmanar Etonnant
Att det körs storlopp i såväl Holland, Italien som Danmark sätter vi fokus på när vi är framme vid veckans avslutande morgonsvep.
