
<p class="has-drop-cap wp-block-paragraph">1Drömmen om att Svenskt Kallblodsderby skulle ta plats på V75-kupongen en lördag var stark, men gensvaret svagt. 1994 ledsnade Östersundstravet så pass på de styrande att Derbyt flyttades till – Solvalla!<br>Derbyt spelade en undanskymd roll i samband med Östersundstravets dubbeltrav som tog fart vid premiären av Jämtlands Stora Pris 1995. Antingen avgjordes loppet kvällen före, eller som ett ramlopp innan V75-spelet drog igång på lördagen. </p>



<p class="wp-block-paragraph">När kallblodsklassikern från och med 2008 dessutom bytte plats i travkalendern och började avgöras i slutet av juli eller början av augusti verkade chansen borta för gott – men i eftermiddag är dag dags! Både Derbyt och Derbystoet finns med på V75-kupongen tillsammans med Jämtlands Stora Pris och övriga rikstotolopp.</p>



<p class="wp-block-paragraph">En av försöksvinnarna är ett minst sagt färgstarkt ekipage. 19-åriga lärlingen Isabella Jansson Wiklund och fyraårige <strong>Bazoo Can</strong> (e. Ängsborken), som tränas av Lindesbergamatören Kai Pakola.<br>– Jag blir inte nervös av mig så ofta och inte nu heller. Såklart ska det bli jätteroligt, jättespännande och allt det där. Och såklart har man drömmar, men det viktigaste är att vara lugn och sprida det över till hästen, säger Isabella <a href="https://sulkysport.se/vi-aker-inte-for-att-forlora/" target="_blank" rel="noreferrer noopener">i en stor intervju med Sulkysport.</a></p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/07/hogdecibel-617x333.jpg" alt="" class="wp-image-749016"/><figcaption class="wp-element-caption">Stig Jarle Röste kunde finåka sista biten när Hög Decibel vann Derbystokval. På lördag är det finaldags. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Bazoo Can ordnade svensk tränarseger i det ena försöket till Kallblodsderbyt. Hagmyrentränaren Stig Jarle Röste svarade för samma bedrift i Derbystoet med familjehästen <strong>Hög Decibel</strong> (e. Art Kjarvald).<br>– Vi har fått lägga om inriktningen lite allt eftersom det blivit tuffare tider för travtränarna, det är inte lätt att få det här att gå ihop. Numera har vi bara åtta hästar på träningslistan och driver sedan också avelsverksamhet under sommartid, säger Camilla Röste, tränarfru, ägare och uppfödare till Hög Decibel, <a href="https://sulkysport.se/hog-decibel-i-derbystoet/" target="_blank" rel="noreferrer noopener">till Sulkysport</a>.</p>



<p class="wp-block-paragraph">Svenska uppstickare mot en total dominant. Sju år i rad (!) har Öystein Tjomsland tränat vinnaren i Svenskt Kallblodsderby. De sju vinnarna är med Philip Ess, Nordsjö Odin, Havglimt, Tangen Bork, Tangen Minto, Bore Mikkel och ifjol Frivoll Gorm. </p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/08/09v75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Östersunds tävlingar idag.</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/2020/11/jonssonalfisulkyn3-617x333.jpg" alt="" class="wp-image-122855"/><figcaption class="wp-element-caption">Alf Jonsson. Foto Stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Att svenska Derbyt brukar sluta med norska nationalsången är allt annat än ovanligt. Sedan norskfödda kallblod släpptes in i loppet 1986 är det stor övervikt Norge bland de 39 vinnare som korats: 30–9!</p>



<p class="wp-block-paragraph">Men första året blev det svenskt – Alf Jonssons <strong>Lundick</strong> (e. Pavjol) vann efter en minst sagt överraskande avslutning. Norska duon <strong>Trons Ruggen</strong> (Egil Flenes) och <strong>Lund Jerker</strong> (Gunnar Eggen) var långt, långt före övriga konkurrenter när det vankades upplopp. Kort före mål kastade sig dock båda hästarna över i galopp och diskvalificerades.</p>



<p class="wp-block-paragraph">En bit där bakom seglade Alf Jonsson fram med sin Lundick, tackade för konkurrenternas galopper och defilerade hem segern i Sveriges största fyraåringslopp för kallblod.<br><em>”Vi var 20–30 meter efter och jag kände mig jätteglad över att kanske kunna bli trea. Men inget av de norska ekipagen ville bli tvåa och det slutade med att båda galopperade över mål och vi fick segern istället. Mitt stora misstag var att följa traditionerna genom att hoppa i tjärnen på innerplan. Det kostade en rejäl förkylning”, </em>berättar Alf Jonsson i boken ”Alf Jonsson: En hästkarls hemligheter”.</p>



<p class="wp-block-paragraph">––> Här är smått &#038; gott inför <a href="https://sulkysport.se/kallblodsdebryt-2025/" target="_blank" rel="noreferrer noopener">Kallblodsderbyt</a> och <a href="https://sulkysport.se/derbystoet-nobbade-hingstens-revansch/" target="_blank" rel="noreferrer noopener">Derbystoet</a>.</p>



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



<p class="has-drop-cap wp-block-paragraph">3Jämtlands Stora Pris har sedan premiären 1995, när <strong>Zoogin</strong> (e. Zoot Suit) slog nybakade Elitloppsvinnaren <strong>Copiad</strong> i en hejdundrande duell, avgjorts över medeldistans med startbil.<br>I årets upplaga drog Daniel Wäjerstens dubble storloppsvinnare i sommar, <strong>Gio Cash</strong> (e. Victor Gio), som besegrat Don Fanucci Zet två gånger om i Norrbottens Stora Pris och Årjängs Stora Sprinterlopp, bakspår.<br>– Han är en oerhört bra häst. Man tror inte att det senaste loppet är sant, med 1.08,5 över 1.600 meter. Bakspår behöver inte vara fel. Han har fått öppna tufft nu två gånger och jag tror att hästen är lika bra bakifrån som i ledningen. Det är en allround häst och det ska bli kul att få känna på hur han funkar i ryggar, säger Wäjersten till Kanal75.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/doubledeceiver2-617x333.jpg" alt="" class="wp-image-449904"/><figcaption class="wp-element-caption">Utvändige Double Deceiver och ledande Gio Cash duellerade i Fyraåringseliten 2023, där Double Deceiver drog längsta strået. Nu möts sexåringarna i Jämtlands Stora Pris. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Han ställs framför allt mot sommarens vinnare av Sweden Cup och S:t Michel-Ajo i Mikkel: Daniel Redén-tränade <strong>Double Deceiver</strong> (e. Cantab Hall).</p>



<p class="wp-block-paragraph">Flest segrar i Jämtlands Stora Pris-historien har <strong>Victory Tilly</strong> (e. Quick Pay) med fyra triumfer – 2000, 2002, 2004 och 2006 – medan Zoogin ståtar med tre 1995-1997.<br><strong>Zoogin</strong> var länge den ende som lyckats försvara sin titel i Jämtlands Stora Pris – två gånger om dessutom.<br>Den bravaden lyckades först Alessandro Gocciadoros <strong>Vernissage Grif</strong> (e. Varenne) upprepa när han triumferade 2021 och 2022 med sin tränare i vagnen, och sedan Daniel Redén-tränade <strong>Hail Mary</strong> (e. Googoo Gaagaa) som tillsammans med Örjan Kihlstöm vunnit de senaste två upplagorna.</p>



<p class="wp-block-paragraph">Löpningsrekordet står i särklass signerat <strong>Readly Express</strong> (e. Ready Cash) från 2018. Hail Mary är näst snabbast med 1.10,4 2023.</p>



<p class="wp-block-paragraph"><strong>Här är de snabbaste vinnarna:</strong></p>



<ul class="wp-block-list">
<li>2018 <strong>Readly Express</strong> (e. Ready Cash) – Jorma Kontio (Timo Nurmos) – 1.10,0a</li>



<li>2023 <strong>Hail Mary</strong> (e. Googoo Gaagaa) – Örjan Kihltröm (Daniel Redén) – 1.10,4a</li>



<li>2019 <strong>Milligan’s School</strong> (e. Yankee Glide) – Carl Johan Jepson (Stefan Melander) – 1.11,0a</li>



<li>2021 <strong>Vernissage Grif</strong> (e. Varenne) – Alessandro Gocciadoro – 1.11,3a</li>



<li>2016 <strong>Call Me Keeper</strong> (e. Pine Chip) – Erik Adielsson (Daniel Redén) – 1.11,4a</li>



<li>2017 <strong>Västerbo Highflyer</strong> (e. Look de Star) – Per Linderoth (Daniel Redén) – 1.11,5a</li>



<li>2024 <strong>Hail Mary</strong> (e. Googoo Gaagaa) – Örjan Kihlström (Daniel Redén) – 1.11,5a</li>
</ul>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v75-tips-hinner-double-deceiver-fore-favoriten/" target="_blank" rel="noreferrer noopener">––> Här är Sulkysports V75-tips till Östersund med viktiga punkter, spikar, drag och systemförslag.</a></p>



<p class="wp-block-paragraph"><em>Vill Du spela V75 tillsammans med Sulkysport?</em><br><a href="https://sulkysport.se/spelstugan/v75-tips-hinner-double-deceiver-fore-favoriten/" target="_blank" rel="noreferrer noopener">Här finns andelar till systemförslaget hos Simsalabim för 150 kr/andel.</a></p>



<p class="wp-block-paragraph">Det tävlas på ytterligare en svensk bana: Tingsryd (första start 11.10) med breddlopp på menyn.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/08/250809.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4 <em>”Vilken lycka!”</em> Det skriver Elisabeth Almheden på Facebook sedan <strong>Maroon Day</strong> gått upp i vikt och fortsätter:</p>



<p class="wp-block-paragraph"><em>”Älskade Rooney har kollats upp och vägts, allt ser bra ut och han har gått upp 35 kg. Trots en flytt och nya rutiner.”</em></p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2025/08/skarmavbild20250808kl.12.33.34.jpg" alt="" class="wp-image-752875"/><figcaption class="wp-element-caption">Maroon Day. Foto: privat</figcaption></figure>



<p class="wp-block-paragraph">För en tid sedan gav Svensk Travsport <a href="https://sulkysport.se/kronika/en-elefant-i-porslinsbutik/" data-type="link" data-id="https://sulkysport.se/kronika/en-elefant-i-porslinsbutik/" target="_blank" rel="noreferrer noopener">startförbud </a>till Maroon Day trots att han var under veterinärvård och inte aktuell för start. Under galgen upphävdes <a href="https://sulkysport.se/st-haver-startforbud-for-maroon-day/" data-type="link" data-id="https://sulkysport.se/st-haver-startforbud-for-maroon-day/" target="_blank" rel="noreferrer noopener">startförbudet </a>av Svensk Travsport, men någon officiell ursäkt för det agerandet kom aldrig…</p>



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



<p class="has-drop-cap wp-block-paragraph">5 Jörgen Sjunnesson är på plats i<strong> Berlin</strong> (första start kl. 12.00)  idag när det körs försök till Tyskt Stoderby (€10.000) och han får chansen bakom Josef Franzls <strong>Uranja</strong> (e. Northern Charm), 1.14,0am/€13.034, vilken han vann bakom i Berlin den 11 maj och körde till en tredjeplats i senaste starten den 13 juli på Mariendorf-banan.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2020/01/sjunnessonjrgensulky.jpg" alt="" class="wp-image-59184"/><figcaption class="wp-element-caption">Jörgen Sjunnesson kör lopp i Berlin idag. Foto Jeannie Karlsson/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Jörgen Sjunnesson har ytterligare fyra uppsittningar – <strong>Viking Silvio</strong>, <strong>Parom</strong>, <strong>Carino Mar </strong>och <strong>His Highness S </strong>– under dagen. </p>



<p class="wp-block-paragraph"><a href="http://www.hvtonline.de/bm/starter/20250809/" data-type="link" data-id="www.hvtonline.de/bm/starter/20250809/" target="_blank" rel="noreferrer noopener">Startlistorna till Mariendorfs tävlingar hittar ni här.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">6 Svenskt på tre franska banor är det idag och största sportsliga höjdpunkten sker i Argentan (första start kl. 16.07). Där bjuds det på ett Grupp II-lopp dock utan blågula inslag, men däremot Elitloppsvinnaren <strong>Hohneck </strong>(e. Royal Dream) i <a href="https://sulkysport.se/elitloppsvinnare-till-start-3/" data-type="link" data-id="https://sulkysport.se/elitloppsvinnare-till-start-3/" target="_blank" rel="noreferrer noopener">Criterium de Vitesse de Basse-Normandie</a> (€120.000) över 1.609 meter autostart.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/7hohneck1-617x333.jpg" alt="" class="wp-image-509508"/><figcaption class="wp-element-caption">Elitloppsvinnaren Honeck startar i Argentan idag. Foto Mathias Hedlund/Sulkysport.</figcaption></figure>



<p class="wp-block-paragraph">Innan Grupp II-löpningen plockar Jörgen Westholm ut <strong>Parker </strong>(e. Bird Parker) i sadelloppet Prix Ce Bello Romain (€30.000) över 2.875 meter med 13.500 euro till vinnaren. En svenskfödd travare dyker också upp i Prix Un Mec d’Heripre (€27.000) och där startar Erik Bondo <strong>Ngannou</strong> (e. Mister J.P.) i ett autostart lopp över 2.150 meter.</p>



<p class="wp-block-paragraph">Mer svenskt blir det i Prix Quaker Jet (€27.000) genom Ron Kuipers <strong>Rustico</strong> (e. Classic Photo) och <strong>Global Duty </strong>(e. Trixton) i ett lopp över 1.609 meter autostart och där det står 12.150 euro på segerchecken.</p>



<p class="wp-block-paragraph"><strong>Enghien</strong> (första start kl. 11.30) är först ut och där tävlar Björn Goops <strong>The Lion </strong>(e. Readly Express) i Prix de Marnes-La-Coquette (€46.000) över 2.150 meter autostart och lånar in Franck Ouvrie. Bland motståndarna finns Marie Norbergs holländare <strong>Nectar Occagnes </strong>(e. S.J.’s Caviar) och svenskfödde <strong>Pure Steel </strong>(e. Bird Parker) i träning hos Erik Bondo.</p>



<p class="wp-block-paragraph">Fyra svenskfödda travare startar i <strong>Cagnes-sur-Mer</strong> (första start kl. 19.30) ikväll i lärlingsloppet Prix de la Mediterranee (€24.000), men ingen i kvartetten – <strong>Enjoy Banker</strong> (e. Lavec Kronos),<strong> Ziva</strong> (e. Varenne), <strong>Luka Modric</strong> (e. Canepa Hanover) och <strong>Digital Indy</strong> (e. Super Photo Kosmos) – finns längre i blågul träning. Distansen är 2.700 meter (auto) och vinnaren kvitterar ut 10.800 euro.</p>



<p class="wp-block-paragraph">En svenskfödd travare – <strong>Silver Bullit</strong> (e. Orlando Vici) – syns i Prix Roller Quick (€36.000) och i det loppet lockas med 16.200 euro i förstapris och distansen är 2.925 meter.</p>



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



<p class="has-drop-cap wp-block-paragraph">7 Det är aldrig för sent att bli medlem i Tusenklubben. Fråga Donald Richards? I torsdags på Plainridge Park räknade han in sin 1.000:e vinnare som tränare när passgångaren <strong>Rys Red Rocket </strong>(e. Sunshine Beach) vann för Matthew Athearn på 1.10,1/1.609 meter.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/08/donaldrichards-617x823.jpg" alt="" class="wp-image-752856"/><figcaption class="wp-element-caption">Donald Richards.</figcaption></figure>



<p class="wp-block-paragraph">Det märkliga i sammanhanget är att ”Donny” Richard är 92 år och still going strong! Karriären inleds med fyra egna hästar 1945 och Cumberland Fair har han haft som bas i åtta decennier.</p>



<p class="wp-block-paragraph">Richards var också framgångsrik i sulkyn och karriären innehöll 4.212 segrar.</p>

Fokustema
Sju nyheter vid sju
Läs senare
Kan någon stoppa Tjomsland?
Blir det åttonde raka segern i Kallblodsderbyt? 30-9 i norrmännens favör. Positivt om Maroon Day. 92-åring tog sin 1.000:e tränarseger. Bakspår inte fel för favorit?
Det är några av Sulkysports nyheter i morgonsvepet.
Det är några av Sulkysports nyheter i morgonsvepet.
