
<p class="has-drop-cap wp-block-paragraph">175.000 kronor till vinnaren i både varm- och kallblodsklassen. Det bjuds i Östersund (första start 18.20) ikväll när Jämtländskt Montémästerskap avgörs för fjärde året. 15 varmblod och 14 kallblod gör upp om de stora prischeckarna och det finns en hel del fina namn.</p>



<p class="wp-block-paragraph">På kallblodssidan – vars uppgörelse är placerad utanför V64-kupongen – finns Sveriges kanske bästa montéhäst i rasen genom tiderna. Umåkeramatören Stefan Dellbros 15-åring <strong>Don Viking</strong> (e. Järvsöviking) är inne på sina sista månader på tävlingsbanan innan pensionslivet väntar. Och Don Viking avslutar verkligen med stil. Han har radat topprestationer i de senaste starterna och slutade bland annat tvåa i Monté-SM för kallblod i näst senaste starten. Det loppet hade valacken vunnit vid tre tillfällen tidigare.<br>60 meters tillägg är uppgiften i kvällens sadellopp tillsammans med ständiga montépartner Lena Fritz. Don Viking har gjort 26 starter i monté och vunnit elva av dem. Totalt har Don Viking gjort 156 starter (34-26-20) och i sulkysammanhang finns bland annat både silver och brons i SM , båda gångerna med <strong>Månlykke A.M.</strong> (e. Månprisen A.M.) som vinnare.</p>



<p class="wp-block-paragraph">På varmblodssidan är inte loppets mest meriterade hästar utpräglade montéhästar, men däremot har de firat framgångar i disciplinen. <strong>Kash Keeper</strong> (e. Uncle Lasse) har gjort fyra starter (2-2-0), <strong>Krakas</strong> (e. Yarrah Boko) har provat fem gånger (0-2-1), medan <strong>Cab Frontline</strong> (e. Caballion) gjort sex montéstarter (2-2-1). </p>



<p class="wp-block-paragraph">De fem framgångsrikaste ryttarna på varmblodssidan i Sverige i år saknas i Östersundsloppen, medan de fyra segerrikaste kallblodsryttarna alla har uppsittningar.</p>



<p class="wp-block-paragraph"><strong>Segerrikaste ryttare varmblod 2024:</strong></p>



<ol class="wp-block-list">
<li>Jonathan Carré, Åby – 106 st: 35-28-15 – 2.649.700 kr</li>



<li>Emilia Leo, Romme – 76 st: 24-14-12 – 1.707.500 kr</li>



<li>Sofia Adolfsson, Örebro – 55 st: 16-10-11 – 1.069.300 kr</li>



<li>Jennifer Persson, Solvalla – 47 st: 11-8-6 – 758.100 kr</li>



<li>Iina Aho, Axevalla – 71 st: 10-8-13 – 704.850 kr</li>
</ol>



<p class="wp-block-paragraph"><em>Statistiken gäller starter på svenska banor.</em></p>



<p class="wp-block-paragraph"><strong>Segerrikaste ryttare kallblod 2024:</strong></p>



<ol class="wp-block-list">
<li>Jenni H Åsberg, Bollnäs – 16 st: 7-1-1 – 266.800 kr</li>



<li>Saga Laursen, Axevalla – 10 st: 4-1-0 – 172.500 kr</li>



<li>Julia Smedman, Solvalla – 12 st: 3-2-1 – 212.400 kr</li>



<li>Tamara Skutnabb, Bergsåker – 8 st: 2-0-0 – 43.700 kr</li>



<li>Martina Berg, Östersund – 4 st: 2-0-0 – 47.000 kr</li>
</ol>



<p class="wp-block-paragraph"><em>Statistiken gäller starter på svenska banor.</em></p>



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



<p class="has-drop-cap wp-block-paragraph">2Östersund (första start 18.20) delar kvällens expresstrav med Kalmar (start 18.30). Där hade Christoffer Eriksson två uppgifter att välja mellan för lovande <strong>Jeriko Brick</strong> (e. Make It Happen), som inlett med fyra segrar på sex starter och aldrig missat pallen. Istället för en spårtrappa för treåringar – där Jeriko Brick fått spår tolv – föll valet på ett dubbelklasslopp mot äldre hästar. Jeriko Brick har fjärdespår i volten och står bra inne på pengarna.</p>



<p class="wp-block-paragraph">Eskilstuna (första start 12.20) inleder fredagen på svensk mark med lunchtävlingar och det är välfyllda lopp. Sju tolvhästars spårtrappor i en delningsproposition, ett tolvhästars försök i Västerbo Daylights stoserie och ett P21-lopp, om än med blott åtta hästar.<br>Det tävlar igen på tisdag kväll i Eskilstuna och kanske ger dagens startvilja utslag på de tävlingarna. Av tisdagens tio lopp är nämligen blott två fyllda och det finns gott om tomma startplatser. </p>



<p class="wp-block-paragraph">Dagens höjdpunkt är Mattias Djuses fyraårige talang <strong>Fine Matters</strong> (e. Chocolatier), som på Elitloppsfredagen tog femte segern på lika många starter när han dundrade runt på 1.11,7a/2.140 meter på Solvalla! Sedan fick hästen strykas från en tilltänkt V75-start och först efter fyra månader var han tillbaka. Då bröts segerraden när han inkasserade livets första förlust i just Eskilstuna. Nu är han tillbaka fö att starta e ny segerrad och Magnus A Djuse sitter som vanligt i sulkyn.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/10/241025.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till fredagens 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/2024/08/6majblomster4-617x333.jpg" alt="" class="wp-image-618979"/><figcaption class="wp-element-caption">Majblomster höll undan i Derbystoet för Mats E Djuse och satte svenskt rekord. Däremot har hon blivit blåst på två andra rekord. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3Som treåring noterade hon fantomtiden 1.23,6a/2.100 meter när hon vann Kriteriestoet på Bjerke och så sent som i lördags på Momarken travade <strong>Majblomster</strong> (e. Tekno Odin) 1,4 sekunder under <strong>Gullan Fax</strong> (e. Järvsöfaks) 20 år gamla gällande svenska rekord för fyraåriga ston över sprinterdistans när hon vann Oaksrevanschen på 1.22,9a/1.640 meter.</p>



<p class="wp-block-paragraph">Ingen av dessa tider får plats i Svensk Travsports lista över svenska rekord.<br>– Sedan årsskiftet 2015-2016 räknar vi endast svenska rekord som sätts på svenska 1.000-metersbanor. Och tidigare, när hästar kunde sätta svenskt rekord utomlands, så var kravet alltid att hästen var svensktränad. Sebastian K. 1.07,7a på Pocono räknades således inte som svenskt rekord 2014 (då Åke Svanstedt hade amerikansk tränarlicens, redds. anm.), har Per Wetterholm på Svensk Travsport berättat för Sulkysport tidigare.</p>



<p class="wp-block-paragraph">Majblomster innehar ändå tre rekordnoteringar, 1.26,4a/2.140 meter för treåriga ston och fyraåringstiderna 1.24,3a/2.140 meter, respektive 1.24,3/2.200 meter voltstart.</p>



<p class="wp-block-paragraph">I rekordrullorna i svensk travsport finns två rekord som satts på utländsk mark fortfarande med i listorna:</p>



<ul class="wp-block-list">
<li>Jan-Olov Persson-tränade <strong>Järvsöfaks</strong> (e. Trollfaks) för sexåriga och äldre kallblod över medeldistans med bilstart – 1.20,1a/2.100 meter noterat på Biri sommaren 2006.</li>



<li>Carlos Söderström-tränade <strong>Bellfaks</strong> (e. Järvsöfaks) för utländska fyraåriga hingstar/valacker över lång distans med bilstart – 1.26,1a/2.600 meter på Momarken 2014.</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">4I natt svensk tid avgörs finalerna i Breeders Crown ($700.000) för tvååringar och svenskarna är heta på bollen, framför allt i stonas final. Av de tio finalisterna tränas åtta av blågula tränare, medan stonas final innehåller fem hästar med svensk anknytning. <br>Sju avelshingstar finns representerade i tvååringarnas finaler. Chapter Seven, Muscle Hill och Tactical Landing har fyra avkommor, medan Gimpanzee, Greenshoe och Walner kommer med en duo. En finalist vardera har Broline-uppstallade Googoo Gaagaa och Muscle Mass. </p>



<p class="wp-block-paragraph">Av avelshingstarna med startande avkommor i årets BC-final har Muscle Hill två titlar för tvååriga hingstar och valacker genom Rebuff och Southwind Frank. Samma visa är det för Chapter Seven (Gimpanzee, Walner), medan Tactical Landing ståtar med en vinst och det var fjolårsvinnaren Karl. </p>



<p class="wp-block-paragraph">I stonas Breeders Crown är Muscle Hill i en klass för sig med fem vinnare; All the Time, Ariana G, Manchego, Mission Brief och Ramona Hill. I år har han tre chanser till en ny seger. Döttrar till Walner – Special Way och Warrawee Michelle – har vunnit de två senaste upplagorna och båda tränade av Åke Svanstedt.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/maximusmearas18102024lisa-617x374.jpg" alt="" class="wp-image-649455"/><figcaption class="wp-element-caption">Svenskfödde Maximus Mearas vinner sitt försök i Breeders Crown för Scott Zeron. Foto: Lisa Photo</figcaption></figure>



<p class="wp-block-paragraph"><strong>Breeders Crown ($700.000), tvååriga ston</strong><br>1.609 meter, autostart. <br><em>Namn (far) – Körsven/tränare</em></p>



<ol class="wp-block-list">
<li>Sound Judgement (e. Muscle Hill) – David Miller/Jim Oscarsson</li>



<li>Delaney Hanover (e. Muscle Hill) – Tim Tetrick/Lucas Wallin</li>



<li>Champagne Problems (e. Tactical Landing) – Scott Zeron/Nancy Takter</li>



<li>Kadena (e. Gimpanzee) – Douglas McNair/Marcus Melander</li>



<li>Lady Landia (e. Tactical Landing) – James MacDonald/Åke Svanstedt</li>



<li>Luna Lovegood (e. Gimpanzee) – Dexter Dunn/Marcus Melander</li>



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



<li>Aperfect Annie (e. Googoo Gaagaa) – Todd McCarthy/Carter Pinske</li>



<li>Spicy Nice (e. Tactical Landing) – Yannick Gingras/Nancy Takter</li>



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



<p class="wp-block-paragraph"><strong>Breeders Crown ($700.000), tvååriga h/v:</strong><br>1.609 meter, autostart. <br><em>Namn (far) – Körsven/tränare</em></p>



<ol class="wp-block-list">
<li>Meshuggah (e. Greenshoe) – James MacDonald/Marcus Melander</li>



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



<li>Maximus Mearas (e. Chapter Seven) – Scott Zeron/Lucas Wallin</li>



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



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



<li>Super Chapter (e. Chapter Seven) – David Miller/Marcus Melander</li>



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



<li>Blank (e. Gimpanzee) – Andrew McCarthy/Marcus Melander</li>



<li>Tactical Dynasty (e. Tactical Landing) – Tim Tetrick/Ron Burke</li>



<li>Memento Mori (e. Chapter Seven) – Anthony MacDonald/Jason McGinnis</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">5På Vincennes ikväll (start 18.23) dyker tre svenskfödda travare dyker upp i Prix Zosma (€53.000) och där startar David Perssons <strong>Sandokan</strong> (e. Maharajah), Björn Goops <strong>Heartbeat Thunder</strong> (e. Scarlet Knight) och Junkie (e. Varenne) i ett lopp för femåringar över distansen 2.100 meter autostart med 23.850 euro. Sandokan gör debut på fransk mark och det gör också Heartbeat Thunder, som anslutit till Goop från Daniel Wäjerstens stall.</p>



<p class="wp-block-paragraph">Vincennes bjuder också på tre Grupp II-löpningar; Prix Uranie (€120.000), Prix Victor Regis (€120.000) och sadelloppet Prix Herve Ceran-Maillard (€120.000). </p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2024-10-25/">Startlistorna till Vincennes tävlingar hittar du här. </a></p>



<p class="wp-block-paragraph">Till Strasbourg (start 11.43) åker Ron Kupier med en Stall Escapade-ägd duo; <strong>Hit Money</strong> (e. Cristal Money) startar i sadelloppet Prix France 3 Alsace (€25.000), medan <strong>General du Nord</strong> (e. Un Mec d’Heripre) går ut i Prix Jamin (€32.000). </p>



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



<p class="has-drop-cap wp-block-paragraph">6En svensktränad tvååring ger sig ut på jakt efter finalplats i Dansk Uppfödningslöpning. Björn Goop sänder <strong>Lucky And Lucky</strong> (e. Ready Cash) till Charlottenlund, där tre försök ska avgöras i eftermiddag. Lucky And Luckyvar fyra i debuten i Lindesberg, men har sedan gjort bort sig i två raka starter. Nu hoppar Robin Bakker upp i sulkyn.</p>



<p class="wp-block-paragraph">Kullens första storlopp i Danmark, Jydsk 2-årings Grand Prix i Ålborg i slutet av september, vanns av Bent Svendsens <strong>Lamborghini C N</strong> (e. Googoo Gaagaa) med Jörgen Sjunnesson i vagnen och med 182.500 danska kronor på kontot är han rikast av de 23 hästarna som försöker kvala in.</p>



<p class="wp-block-paragraph">De fyra främsta i varje försök kvalificerar sig för finalen på Charlottenlund söndag den 10 november. Där väntar 218.000 danska kronor – cirka 330.000 svenska – på vinnaren.</p>



<p class="wp-block-paragraph"><a href="https://www.travbanen.dk/media/ft1fsmj0/lunden_25-10-24_n.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till eftermiddagens tävlingar på Lunden.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">72023 gjordes uppläggen för Breeders Crown-försöken om. Sju försök per år blev nio och samtidigt skulle de 27 tävlingsdagarna under en treårsperiod fördelas på landets 27 permanenta banor.</p>



<p class="wp-block-paragraph">Nu är datumen fastställda för nästa års Breeders Crown-försök, som inleds i Eskilstuna den 8 april och avslutas med dubbla försöksomgångar på Åby och Bergsåker den 15 oktober.</p>



<p class="wp-block-paragraph"><strong>Så här körs Breeders Crown-försöken 2025:</strong></p>



<ul class="wp-block-list">
<li>8 april – Eskilstuna</li>



<li>22 maj – Årjäng</li>



<li>19 juni – Dannero</li>



<li>30 juli – Visby</li>



<li>10 augusti – Vaggeryd</li>



<li>10 september – Umåker</li>



<li>12 september – Solvalla</li>



<li>15 oktober – Åby</li>



<li>15 oktober – Bergsåker</li>
</ul>



<p class="wp-block-paragraph">Årets Breeders Crown-säsong för tre- och fyraåringar närmar sig sitt slut och nästa söndag den 3 november väntar semifinaler på Solvalla.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/de-har-kvalat-in-till-breeders-crown/" target="_blank" rel="noreferrer noopener">Här är hästarna som kvalat in till semifinalerna.</a></p>

Fokustema
Sju nyheter vid sju
Läs senare
15-åring i sista mästerskapet
15-åringen i sitt sista montémästerskap. Kulldrottning ”blåst” på två svenska rekord. 13 av 20 tvååringar svensktränade i Breeders Crown-finaler i USA. Blågula debutanter på Vincennes. Goop kvalar i Uppfödningslöpningen.
Detta och mer i fredagens ”Sju nyheter vid sju”.
Detta och mer i fredagens ”Sju nyheter vid sju”.
