
<p class="has-drop-cap">1 Vinnare av Guldstoet och en division i Margaretas Tidiga Unghöstserie förra året. 2023 har inte varit lika framgångsrikt för Hans R Strömbergs sto <strong>Xerava C.D. </strong>(e. Uncle Lasse), men i somras kvalade hon in till Stochampionatet. Ikväll dyker hon upp på hemmaplan i Rättvik (första start 18.20) och tränare Strömberg sitter själv i sulkyn i jakt på årets första seger.<br>En annan unghäststjärna dyker också upp i loppet. 2020 vann <strong>Mi Ma Orthus</strong> (e. Jocose) tvååringsloppet Svampen i Joakim Elfings regi. Hästen finns numera i uppfödaren Anna Maria Hanses stall och gör andra starten på drygt 1,5 år.</p>



<p>På tal om hästar med unghästmeriter. På kvällens andra xpressbana Kalmar (start 18.30) plockar hemmatränaren Fredrik Persson ut <strong>Deborah S.H.</strong> (e. Maharajah) i ett sprinterlopp där Deborah S.H. som sto har fått tjäna mer än konkurrenterna. Andraplatsen i Drottning Silvias Pokal förra året är främsta meriten för stoet som även varit finalist i Oaks och Stochampionatet samt tvåa i Diana Zets lopp.<br>Nu närmar hon sig två miljoner kronor insprunget. I år har det blivit en seger, på hemmaplan i ett stolopp i augusti.</p>



<p>Både Rättvik och Kalmar bjuder på årets första tvååringslopp på banorna. Rättviks har lockat blott fyra deltagare, medan nio slutet upp i Kalmar. </p>



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



<p class="has-drop-cap">2 Vilka är Östersundstravets bästa hästar? Dagens lunchtävlingar (första start 12.20) ger kanske inte svar på den frågan, men två nya lopp på Jämtlandsbanan tar plats i programmet. Det handlar om Östersundsmästaren för både varm- och kallblod, där endast hästar hos tränare med A- eller B-licens i Östersund får vara med.</p>



<p>Loppen är öppna för alla hästar och utskrivna med flera volter. I kallblodsloppet kommer 13 hästar till start från fem volter, där duon <strong>Bonaldo</strong> (e. Spikeld) och <strong>Blixen</strong> (e. B.W.Modde) inleder från 80 meters tillägg över medeldistans.<br>Varmblodens upplaga saknar de rikaste hästarna, men 14 hästar möts från tre volter. Här gör tidigare Daniel Redén-tränade sjuåringen <strong>Magnificent Tooma</strong> (e. S.J.’s Caviar) debut i Oscar Berglunds regi och möter i sin första start för året bland annat Per Linderoths <strong>Knockout Keeper</strong> (e. Lavec Kronos), som startar 20 meters före.<br><em>”Fina 50.000 kronor till vinnarna och en rolig grej att göra vid detta enskilda tillfälle,” </em>skriver B-O Månsson i banprogrammet.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/10/231006.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till fredagens tävlingar.</a></p>



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



<p class="has-drop-cap">3 Fem divisioner bjuds det på i International Stallion Stakes ($67.800) för tvååriga hingstar och valacker på Red Mile ikväll svensk tid och matchen mellan Nancy Takters obesegrade <strong>Karl </strong>(e. Tactical Landing) och dollarmiljonären <strong>T C I</strong> (e. Cantab Hall) är förstås den division som drar till sig störst intresse.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/09/karlygm230804adamstromstalltz-617x373.jpg" alt="" class="wp-image-491384"/><figcaption class="wp-element-caption">Karl och Yannick Gingras. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>De blågula tränarna är flitigt representerade i International Stallion Stakes ($67.800) och följande hästar startar:</p>



<p><strong>Namn (far) – Tränare</strong></p>



<ul class="wp-block-list">
<li><strong>Bargain</strong> (e. Chapter Seven) – Nancy Takter</li>



<li><strong>Bryant Bros</strong> (e. Varenne) – Åke Svanstedt</li>



<li><strong>Crown Monarch</strong> (e. Father Patrick) – Per Engblom</li>



<li><strong>Daiquiri Hanover </strong>(e. Bar Hopping) – Åke Svanstedt</li>



<li><strong>Karl </strong>(e. Tactical Landing) – Nancy Takter</li>



<li><strong>Loxahatchee</strong> (e. Greenshoe) – Marcus Melander</li>



<li><strong>Magic Hill </strong>(e. Muscle Hill) – Nancy Takter</li>



<li><strong>Mosquito </strong>(e. Muscle Hill) – Lucas Wallin</li>



<li><strong>Mr Bluebird</strong> (e. Six Pack) – Åke Svanstedt</li>



<li><strong>My Way</strong> (e. Muscle Hill) – Marcus Melander</li>



<li><strong>Security Protected</strong> (e. Father Patrick) – Marcus Melander</li>



<li><strong>Situationship</strong> (e. Chapter Seven) – Åke Svanstedt</li>



<li><strong>Southwind Metric</strong> (e. Walner) – Åke Svanstedt</li>



<li><strong>Thinker Monkey</strong> (e. Chapter Seven) – Marcus Melander</li>



<li><strong>Wild Ticket</strong> (e. Chapter Seven) – Marcus Melander</li>
</ul>



<p><a href="https://racing.ustrotting.com/goto.aspx?target=12,92133" data-type="link" data-id="https://racing.ustrotting.com/goto.aspx?target=12,92133">Startlistorna till fredagens tävlingar hittar ni här.</a></p>



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



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/01/bordeaux5-617x362.jpg" alt="" class="wp-image-400299"/><figcaption class="wp-element-caption">Bordeaux S. vid storseger i Cagnes-sur-Mer. Idag gör hästen comeback på Vincennes. Foto: Gerard Forni.</figcaption></figure>



<p class="has-drop-cap">4Efter en stark vintermeeting med dubbla segrar fick svenskfödde <strong>Bordeaux S. </strong>(e. Orlando Vici) en längre tävlingspaus, men ikväll är han redo för comeback. Sjuåringen kommer till start i Quinté-loppet Prix Charley Mills (€75.000) på Vincennes (första start kl. 16.38) tillsammans med lärlingen Guillermo Horrach Vidal och Jean-Michel Bazire låter sjuåringen tävla med skor på hovarna.</p>



<p>Däremot är det barfota runt om på såväl Johan Svenssons <strong>Kuyt F Boko</strong> (e. Conway Hall) och Markus B Svedbergs <strong>Loaded Maria </strong>(e. Trixton) i samma lopp.</p>



<p>Även Tomas Malmqvist prövar lyckan i den franska huvudstaden då <strong>Kapla Devol</strong> (e. Che Jenilou) syns i Prix Etamin (€46.000) tillsammans med Alexis Collette.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2023-10-06/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna på Vincennes.</a></p>



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



<p class="has-drop-cap">5Den norske Derbyvinnaren <strong>Born In Bergen</strong> (e. Born In the U.S.A.) kommer till start i danska Odense (första start 15.45) under fredagseftermiddagen då Sprintermästaren ska avgöras.</p>



<p>Fram tills år 2021 kördes loppet i Billund, men efter att Legoland köpt marken där banan legat belägen är det i Odense som klassikern numera avgörs.</p>



<p>Kim Pedersens topphäst inleder från spår åtta bakom bilen i lag med Björn Steine och det är långt ifrån säkert att han får bära på favoritskapet när Bo Westergårds Thewinnertakesitall (e. Muscle Hill) och Hans Henning Kristoffersens<strong> Henrik Will </strong>(e. Great Challenger) finns på insidan.</p>



<p><strong>Startlista Sprintermesteren</strong><br><em>1.640 meter autostart, förstapris: 100.000 danska kronor</em></p>



<ol class="wp-block-list">
<li>Hugo Tröjborg (e. Hillustrious) – Kasper Foget (Bo Westergård)</li>



<li>Hurricane K K (e. Ens Snapshot) – Rene Kjaer</li>



<li>Hurricane Photo (e. S.J.&#8217;s Photo) – Bjarke Haagensen</li>



<li>Thewinnertakesitall (e. Muscle Hill) – Bo Westergård</li>



<li>Hollywood Stone (e. Wishing Stone) – Nicklas Korfitsen (Bo Westergård)</li>



<li>Hero Boom Bay (e. Donato Hanover) – Kasper K Andersen (Torben Hovgaard)</li>



<li>Henrik Will (e. Great Challenger) – Ken Ecce (Hans Henning Kristoffersen)</li>



<li>Born In Bergen (e. Born In the U.S.A.) – Björn Steine (Kim Pedersen)</li>



<li>Howlingatthemoon (e. Cantab Hall) – Jan Dahlgaard (Peter Rudbeck)</li>



<li>Handsome Henry W A (e. From Above U S) – Anders F Jensen</li>
</ol>



<p><a href="https://www.epaper.dk/danskhv/fvb/odense_06-10-23/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens banprogram till tävlingarna i Odense.</a></p>



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



<p class="has-drop-cap">6Uttrycket &#8221;finsk matchning&#8221; med täta starter gör så onekligen gällande när det kommer till den <strong>God Hyperion</strong> (e. Brad de Veluwe)1.14,6al/€103.400.</p>



<p>I lördags vann Timo Korvenheimos hästen Finskt Travkriterium i lag med Henri Bollström och redan ikväll är den färske storloppsvinnaren tillbaka på tävlingsbanan när det avgörs Breeders Crown-försök i Åbo.</p>



<p>Det avgörs även klasser för treåriga ston, fyraåriga diton samt fyraåriga hingstar och valacker, men God Hyperion är ensam av de 47 hästarna som tävlar i kvällens BC-lopp att tjänat över 100.000 euro.</p>



<p><a href="https://heppa.hippos.fi/heppa/app?ct=YXBwbGljYXRpb24vcGRm&#038;d=dHJ1ZQ%3D%3D&#038;dr=&#038;f=b2hqZWxtYXRpZWRvdC5US18wNi4xMC4yMDIzLnBkZg%3D%3D&#038;m=2xH%2BRkfVfa%2FKJwNYrLBjOv2ABME%3D&#038;r=MTY5NjQ0Nzg2NjMwNQ%3D%3D&#038;service=pdftmp" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistor till tävlingarna i Åbo.</a></p>



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



<p class="has-drop-cap">7 Robert Bergh har stärkt upp stallet med två hästar som slutat tvåa i STL-lopp. Under gårdagen anslöt <strong>Center Bus</strong> (e. Scarlet Knight) 1.12,7ak/344.900 kr från Axevallaamatören Thomas Pettersson vilket slutade tvåa i ett Klass II-försök på Jägersro under fjolårets derbyhelg.</p>



<p>För en knapp månad sedan fick Bergsåker/Åbytränaren även in Trixton-dottern<strong> Irma Sisu</strong>, 1.12,7ak/426.340 kr från Robert Skoglund. Hon slutade tvåa i ett Diamantstoförsök i Boden i juni och var i farten redan som tvååring då hon i Mattias Djuses regi slutade femma i Grupp II-klassade Svampen i Örebro.</p>

Fokustema
Morgonsvepet
Läs senare
Avlägger årsmaiden?
Om kvällens unghästtoppar som startar på Romme och i Kalmar, superduell på The Red Mile och den danska versionen av Sprintermästaren går bland annat att läsa i veckans femte morgonsvep.
