
<p class="has-drop-cap wp-block-paragraph">1Svenska framgångarna i Kentucky Futurity har varit anmärkningsvärda de senaste elva åren. Jimmy Takter vann både 2014 och 2015 med<strong> Nuncio</strong> respektive <strong>Pinkman</strong> och därefter har det blivit triumfer för Åke Svanstedts <strong>Six Pack </strong>(2018), Marcus Melander <strong>Greenshoe</strong> (2019), Lucas Wallins <strong>Rebuff </strong>(2022) och Nancy Takter <strong>Tactical Approach</strong> (2023).</p>



<p class="wp-block-paragraph">Det ser minst sagt bra ut på förhand även inför årets upplaga av stoloppet på Red Mile i Lexington. Sju av elva hästar är nämligen tränade av svenskar och Marcus Melander sitter i förarsätet med fem startande hästar!<br>Åke Svanstedts Hambletonian-vinnare <strong>Northern Catcher</strong> (e. Six Pack) är skadad och saknas, men sex av finalisterna från storloppet i augusti finns med i kvällens storlopp. Bland dessa finns Marcus Melanders tvåa <strong>Super Chapter</strong>, trea <strong>Maryland</strong>, Svanstedts fyra <strong>Gap Kronos</strong>, Loc Blais femma <strong>Emoticon Legacy</strong> och Melanders sexa <strong>Meshuggah</strong>!</p>



<p class="wp-block-paragraph"><strong>Startlista Kentucky Futurity ($500.000)</strong><br>1.609 meter autostart, Red Mile<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Fashion Green (e. Greenshoe) – Tim Tetrick (Jim Campbell)</li>



<li>Meshuggah (e. Greenshoe) – Scott Zeron (Marcus Melander)</li>



<li>Onajetplane (e. Walner) – Andrew McCarthy (Noel Daley)</li>



<li>Super Chapter (e. Chapter Seven) – Dexter Dunn (Marcus Melander)</li>



<li>Variegated (e. Chapter Seven) – Jason Bartlett (Marcus Melander)</li>



<li>Gap Kronos (e. Face Time Bourbon) – James MacDonald (Åke Svanstedt)</li>



<li>Go Dog Go (e. Greenshoe) – Todd McCarthy (Carter Pinske)</li>



<li>Happy Jack B (e. Chapter Seven) – Åke Svanstedt</li>



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



<li>Emoticon Legacy (e. Walner) – Louis Roy (Luc Blais)</li>



<li>Maryland (e. Chapter Seven) – Yannick Gingras (Marcus Melander)</li>
</ol>



<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/09/delaneyhanoverszpr250927adamstromstalltz-617x375.jpg" alt="" class="wp-image-772986"/><figcaption class="wp-element-caption">Glädje i vinnarcirkeln efter Delaney Hanovers seger. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Det handlar inte bara om Kentucky Futurity på Red Mile idag och de blågula tränarna startar flitigt i storloppen. I stoavdelningen Kentucky Futurity Filly ($300.000) är fem av elva deltagare tränade av svenskar. Det största svenska hoppet är kanske Lucas Wallin-tränade <strong>Delaney Hanover</strong> (e. Muscle Hill), som slutade trea i Hambletonian Oaks och har sprungit in 361.585 dollar hittills i karriären.</p>



<p class="wp-block-paragraph"><strong>Startlista Kentucky Futurity Filly ($300.000)</strong><br>1.609 meter autostart, Red Mile<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Country Victory (e. International Moni) – David Miller (Melvin Schmucker)</li>



<li>Miss Belmar (e. Muscle Hill) – Andrew McCarthy (Noel Daley)</li>



<li>Delaney Hanover (e. Muscle Hill) – Scott Zeron (Lucas Wallin)</li>



<li>R Charm (e. Propulsion) – Todd McCarthy (Linda Toscano)</li>



<li>Deja Blu (e. Muscle Hill) – Yannick Gingras (Ron Burke)</li>



<li>What A Bid Hanover (e. Muscle Hill) – Åke Svanstedt</li>



<li>Kadena (e. Gimpanzee) – James MacDonald (Marcus Melander)</li>



<li>Stash Some Cash (e. Walner) – Dexter Dunn (Domenco Cecere)</li>



<li>R Dutchess (e. Father Patrick) – Tim Tetrick (John Butenschoen)</li>



<li>Royal Mission (e. Chapter Seven) – Doug McNair (Marcus Melander)</li>



<li>Champagne Problems (e. Tactical Landing) – Jason Bartlett (Nancy Takter)</li>
</ol>



<p class="wp-block-paragraph"><strong>Här är övriga blågula hopp på det röda gruset:</strong></p>



<ul class="wp-block-list">
<li><strong>Allerage Trot Open ($160.000):</strong> Periculum (Marcus Melander), French Wine (Nancy Takter), Get A Wish (Åke Svanstedt), Security Protected (Marcus Melander), Up Your Deo (Åke Svanstedt), Aetos Kronos (Marcus Melander)</li>



<li><strong>Allerage Trot Mares ($80.000):</strong> Bravo Angel (Per Engblom), Date Night Hanover (Marcus Melander), Nelson Brit Eagle (Åke Svanstedt), Warrawee Michell (Åke Svanstedt), Dial Square (Åke Svanstedt)</li>



<li><strong>Kentucky Eligbles ($50.000): </strong>The Rouge Prince (Lucas Prince), Blank (Marcus Melander), Warrior (Åke Svanstedt), Donät Ask For Me (Åke Svanstedt), Mr Mouton (Åke Svanstedt)</li>



<li><strong>Kentucky Filly Eligbles ($25.000): </strong>Xalapa (Nancy Takter), C Me B Me (Lucas Wallin), Spicy Nice (Nancy Takter)</li>
</ul>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/10/redmile5102025.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till kvällens tävlingar på Red Mile.</a></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/2024/12/kristianlindbergsulky-617x333.jpg" alt="" class="wp-image-666904"/><figcaption class="wp-element-caption">Kristian Lindberg. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3I Årjäng (första start 13.45) närmar sig säsongen sitt slut och efter dagens tävlingar återstår endast lunchtävlingar i början av november. Därför blir det ”finalprägling” på tävlingarna idag. Årjängsmästaren 2024 för både varmblod och kallblod avgörs med 100.000 kronor till vinnaren i varmblodsklassen och 75.000 för kallbloden.<br>För att en häst ska vara startberättigad i finalen måste den ha startat minst en gång på Årjängstravet under 2024 och det har samlats poäng hela säsongen.</p>



<p class="wp-block-paragraph">Förra året blev hemmatränaren Kristian Lindberg champíon i Årjäng, men i år ligger han tre segrar bakom ledande Björn Goop med två tävlingsdagar kvar. Fast i Årjängsmästaren för varmblod har Kristian det väl förspänt. Han kör själv <strong>Hickovelocissimo</strong> (e. Explosive Matter), som vunnit tre av fyra starter i år, på startfållan och 40 meter bakom startar en annan segervan travare, stallkamraten <strong>Fourwhitesocks</strong> (e. Hard Livin), med fem vinster på 13 försök.<br>I kallblodens upplaga kommer de starkaste korten från Norge i <strong>Björn Borksson</strong> (e. Björn Bork) och <strong>Fröyu Jerken</strong> (e. Bork Odin).</p>



<p class="wp-block-paragraph">Söndagen inleds med breddplus-tävlingar i Vaggeryd (start 11.10) för hästar med högst 800 poäng. Veikko Haapakangas italienska sto <strong>Chanel Trio</strong> (e. Nad al Sheba) har matchats i tuffa gäng och rusade bland annat 1.08.6 första kilometern i diamantstoets final under Elitloppshelgen. Det bar inte hela vägen och nu kliver hon ned i klass rejält efter drygt tre månaders tävlingsuppehåll. </p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/10/251005.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar.</a></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/09/00280179018scoopdyga-617x411.jpg" alt="" class="wp-image-767192"/><figcaption class="wp-element-caption">Power Doc och Franck Ouvrie vann på Vincennes. Foto. Scoopdyga</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4Det tävlas på tolv banor i Frankrike idag och för blågul del vänds blickarna främst mot tusenmetersbanan i Angouleme i västra Frankrike. Där dyker nämligen hästar från fem svenska tränare upp.</p>



<p class="wp-block-paragraph">Fyra av dem möts i Europaloppet Grand Prix des Trotteurs (€23.000) över 2.750 meter med 10.350 euro till vinnaren. Åke Lindbloms <strong>Power Doc</strong> (e. Muscle Massive) finns i träning hos Markus B Svedberg och gjorde stora avtryck i första satrtn på fransk mark för Svedberg när han vann på starka 1.10,4a/2.100 meter på Vincennes! Nu startar han över lång distans och från 25 meters tillägg. Franck Ouvrie sitter i vagnen igen.<br>För Jasmine Ising blev det en drömstart på franska äventyret för <strong>Ferox Brick</strong> (e. Orlando Vici), som vann direkt i första starten i Frankrike. Nu sitter Gabriele Gelormini i vagnen bakom den segervane åttaåringen.<br>Övriga svenskar är Joakim Eskilssons <strong>Master of Zon</strong> (e. The Bank) och Johan Untersteiners <strong>Mateo di Quattro</strong> (e. Bird Parker).</p>



<p class="wp-block-paragraph">I ett lopp för franska hästar startar Jörgen S Eriksson fyraårige <strong>Loyal Eleven</strong> (e. Fastissime), som får Franck Ouvrie i vagnen i kamp om 6.975 euro.</p>



<p class="wp-block-paragraph">I Rambouillet plockar Marie Norberg ut <strong>Miss d’Elfe</strong> (e. Discours Joyeux) i ett treåringslopp med 6.300 euro till vinnaren. Loppet är delat i tre avdelningar och i en annan finns Stall Escapades <strong>Marquis du Nord</strong> (e. Un Mec d’Heripre).</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/2022/05/11oscarl.a.1-617x333.jpg" alt="" class="wp-image-308244"/><figcaption class="wp-element-caption">Oscar L.A. vid överlägsen seger under Elitloppshelgen 2022 för Joakim Lövgren. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5I samband med fredagens storlopp i Hamburg tackade Tingsryds banrekordhållare för sig. Svenskfödde nioåringen <strong>Oscar L.A.</strong> (e. Ready Cash) lägger tävlingsskorna på hyllan. Hästen är uppfödd och ägs av Günter Herz och inledde tävlingskarriären med ett fåtal starter hos Josef Franzl innan han firade sina största framgångar hos Joakim Lövgren. Efter en period hos Fabrice Souloy och Franzl, så avslutade han karriären hos Alessandro Gocciadoro.</p>



<p class="wp-block-paragraph">Totalt gjorde Oscar L.A. 62 starter (24-6-5) och de två största prischeckarna kom vid andraplatserna i Oslo Grand Prix och Kymi Grand Prix i Lövgrens regi.<br>I somras travade Oscar L.A. 1.08,5a/1.609 meter när han satte nytt banrekord i Tingsryd med Ulf Ohlsson i vagnen.</p>



<p class="wp-block-paragraph">Oscar L.A. är undan tyskan <strong>Esperance</strong> (e. Abano As), 1.16,1ak/49.195 kr, som vann fem av 17 lopp. Förutom fyrfaldige miljonären Oscar L.A. har hon också lämnat <strong>Lesparanza</strong> (e. Ready Cash), 1.11,3ak*/1.176.851 kr.</p>



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



<p class="has-drop-cap wp-block-paragraph">6Norskamerikanen <strong>Devilish Hill</strong> (e. Muscle Hill) trotsade stormen Amy och reste från Oslotrakten till Bergen för att plocka hem Kniksens Minneslopp och 100.000 norska kronor i Bergen igår kväll. Magnus Teien Gundersen satt i vagnen bakom hästen som tränas av pappa Geir Vegard och efter tidig ledning spänstade han undan till överlägsen seger i finfin stil i blötan efter att ha varvat på 1.17. Segertiden skrevs till enkla 1.14,5a/2.100 meter, men intrycket var gott.</p>



<p class="wp-block-paragraph">Nu vänds blickarna söderut för den USA-födde femåringen, som vunnit tio av 37 starter och sprungit in 3.641.121 norska kronor.<br>– Det här gjorde han väldigt lätt, han behövde inte springa fortare. Planen är att starta i Italien i slutet av månaden, sade skötaren Lise Alme till Trav- og Galopp Nytt efteråt.</p>



<p class="wp-block-paragraph">Loppet det bör handla om i så fall för Devilish Hill är Gran Premio delle Nazioni i Milano den 1 november. Loppet ingår i nästa säsongs UET Elite Circuit och hade förra året 220.000 euro i prissumma.</p>



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



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2025/09/202505191523blizzarddiamantz180525fkopie.jpg" alt="" class="wp-image-767616"/><figcaption class="wp-element-caption">Blizzard DIamant. Källa: Daglfing/München</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">7Efter fredagens storlopp för fyraåringar – Grosser Preis von Deutschland – är det de yngre travarna som är i fokus i Hamburg idag. Tvååringarna gör upp i TCT Classic Race med 12.000 euro i potten i två klasser, men de stora pengarna gör treåringarna upp om treåringskriteriet.</p>



<p class="wp-block-paragraph">Fem hästar sluter upp i stoklassen, medan blott fyra hingstar och valacker är anmälda. En av dessa är färske Europarekordtravaren <strong>Blizzard Diamant</strong> (e. Indigious) från Paul Hagoorts stall. Valacken slog till med fenomenala 1.10,0a/1.640 meter när han vann Åby Stora Treåringspris i mitten av augusti och skrev in sig i rekordböckerna.</p>



<p class="wp-block-paragraph"><a href="https://www.hvtonline.de/hb/starter/20251005/" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar.</a></p>



<p class="wp-block-paragraph"><strong>Startlista Treåringskriteriet h/v</strong><br>2.200 meter autostart, förstapris 25.000 euro<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li>Sir Hans (e. Hans Hazelaar) – Dion Tesselaar</li>



<li>Harry Angel (e. Quick Wood) – Jeffery Mieras</li>



<li>Red Five (e. Maharajah) – Jaap van Rijn</li>



<li>Blizzard Diamant (e. Indigious)– Robin Bakker</li>
</ol>



<p class="wp-block-paragraph"><strong>Startlista Treåringskriteriet ston</strong><br>2.200 meter autostart, förstapris 25.000 euro<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li>Xalina B. (e. Booster Winner) – Marisa Bock</li>



<li>Gazzaladra Font (e. Love You) – Michael Nimczyk</li>



<li>Northern Rose (e. Northern Charm) – Josef Franzl</li>



<li>Chuupette (e. Maharajah) – Thorstein Tietz</li>



<li>Bumblebee Diamant (e. Indigious) – Dion Tesselaar</li>
</ol>



<p class="wp-block-paragraph"></p>

Fokustema
Sju nyheter vid sju
Läs senare
Hamborevansch med alla utom en
Alla stjärnor är med utom Svanstedts Hambovinnare. Svenska dominansen i storloppet. Tingsryds snabbaste travare slutar. Norskt Elitloppshopp till Italien. Europarekordhållare möter tre hästar.
Detta och mer bland söndagens ”Sju nyheter vid sju”.
Detta och mer bland söndagens ”Sju nyheter vid sju”.
