
<p class="has-drop-cap wp-block-paragraph">1 – Tänk att Järvsöfaks sprang 1.29 som treåring och 1.25 som fyraåring. Majblomster har redan sprungit 1.23,6.</p>



<p class="wp-block-paragraph">Så sade Jan-Olov Persson i vintras när han summerade <strong>Majblomsters</strong> (e. Tekno Odin) fenomenala treåringssäsong med triumfer i Kriteriestoet, Stokriteriet och Oaks toppat med världsrekordnoteringen 1.23,6a/2.100 meter vid segern på Bjerke.</p>



<p class="wp-block-paragraph">Förväntningarna inför årets fyraåringssäsong var skyhöga och Majblomster har levt upp till dem. Med sex segrar på lika många starter 2024 kliver hon ut som  storfavorit i Derbystoet ikväll. Men konkurrenterna andas morgonluft.<br><strong>Troll Sterkfaksine</strong> (e. Tekno Odin) slog Majblomster i kval till norska Stokriteriet, konstaterade tränaren Jan Roar Mjölneröd. <strong>Prinsesse Ness Tjo</strong> (e. Moe Odin) har längre segersvit än svenskan med elva raka mot Majblomsters nio och kusken bakom knappt slagna tvåan i Majblomsters försök, Lars Anvar Kolle, säger att han körde på säkerhet med <strong>Voje Lotta</strong> (e. Ängsborken) för att säkra finalplatsen.</p>



<p class="wp-block-paragraph">Upp till bevis i finalen!</p>



<p class="wp-block-paragraph"><strong>Snabbaste vinnarna i Derbystoet:</strong></p>



<ul class="wp-block-list">
<li>1.23,9 – Patsi (e. Åsajerven – Tekno Pila), 2016, Öystein Tjomsland</li>



<li>1.25,2 – Norheim Borka (e. Bork Odin – Norheim Elle), 2020, Örjan Kihlström</li>



<li>1.25,3 – Vega N.O. (e. Åsajerven – Tema), 2023, Öystein Tjomsland</li>



<li>1.25,8 – Nordsjö Anna (e. Tekno Odin – Nordli Vinni), 2022, Öystein Tjomsland</li>



<li>1.26,0 – April Faxa (e. Smedheim Solan – Valle Faxa), 2021, Vidar Hop</li>



<li>1.26,2 – Glade Tider (e. Bork Odin – Gyldne Tider), 2019, Jomar Blekkan</li>



<li>1.26,4 – Brenne Blissi (e. Lome Elden – Brenne Järva), 2017, Åsbjörn Tengsareid</li>



<li>1.26,5 – Stjärnblomster (e. B.W.Modde – Järvsöblomster), 2018, Örjan Kihlström</li>
</ul>



<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 38 vinnare som korats: 29–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 Trons Ruggen (Egil Flenes) och Lund Jerker (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"><a href="https://sulkysport.se/kallblod-utmanad-fran-tva-hall/" target="_blank" rel="noreferrer noopener">––> Här är smått &#038; gott inför Kallblodsderbyt och Derbystoet.</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/2023/05/frodehamre-617x333.jpg" alt="" class="wp-image-450191"/><figcaption class="wp-element-caption">Frode Hamre. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3Frode Hamre är Norges framgångsrikaste travtränare och han är unik när det gäller en sak: klassiska segrar som tränare. Hamre är nämligen den ende som vunnit Kriteriet, Stokriteriet, Derbyt och Derbystoet i Norge – med båda raserna! </p>



<p class="wp-block-paragraph"><strong>Här är Frode Hamres klassiska vinnare i Norge som tränare:</strong></p>



<ul class="wp-block-list">
<li>Derbyt, varmblod: El Diablo B.R., Charlestone Volo </li>



<li>Derbyt, kallblod: Ingbest</li>



<li>Stoderbyt, varmblod: Calina</li>



<li>Stoderbyt, kallblod: Karmland Anna</li>



<li>Kriteriet, varmblod: Thai Michigan</li>



<li>Kriteriet, kallblod: Overvik Prinsen</li>



<li>Stokriteriet, varmblod: Jolene B.R., Meghan B.R.</li>



<li>Stokriteriet, kallblod: Karmland Anna</li>
</ul>



<p class="wp-block-paragraph">Ifjol segrade <strong>Overvik Prinsen</strong> (e. Will Prinsen) i Kriteriet i både Sverige och Norge och är den häst som gjorde Hamres meritlista ovan komplett vid segern på Bjerke. Ikväll kan hingsten ordna Hamres första Derbyseger i Sverige.<br>– Han fungerade fint i kvalet och har verkat bra i träning efteråt. Overvik Prinsen hade inte startat sedan slutet av september och har gått framåt med ett lopp i kroppen. Det är jag inte lika säker på att konkurrenterna har gjort. Jag känner mig trygg i att hästen kommer att göra ett bra lopp, säger Hamre till Trav- og Galopp-Nytt.</p>



<p class="wp-block-paragraph">Hans landsman Öystein Tjomsland ger inte upp på förhand – med sex raka segrar i Svenskt Kallblodsderby och två av tre försöksvinnare i stallet!</p>



<p class="wp-block-paragraph"><strong>De snabbaste vinnarna i Svenskt Kallblodsderby:</strong></p>



<ul class="wp-block-list">
<li>1.22,0 – Nordsjö Odin (e. Tekno Odin – Nordli Vinni), 2019, Öystein Tjomsland</li>



<li>1.22,6 – Tangen Bork (e. Bork Odin – Tangen Stöva), 2021, Tom Erik Solberg</li>



<li>1.22,9 – Tekno Odin (e. Moe Odin – Lyana), 2012, Öystein Tjomsland</li>



<li>1.23,1 – Lannem Silje (e. Åsajerven – Lannem Sjura), 2014, Tor Wollebaek</li>



<li>1.23,1 – Bore Mikkel (e. Moe Odin – Ridder Rosa), 2023, Öystein Tjomsland</li>



<li>1.23,5 – Tangen Minto (e. Bork Odin – Mangen Mina), 2022, Tom Erik Solberg</li>



<li>1.24,0 – Philip Ess (e. Briskeby Philip – Tangen Pia), 2019, Öystein Tjomsland</li>



<li>1.24,0 – Havglimt (e. Moe Odin – Sjefslill), 1.24,0, 2020, Öystein Tjomsland</li>
</ul>



<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/07/epickronos-617x333.jpg" alt="" class="wp-image-604299"/><figcaption class="wp-element-caption">Epic Kronos övertygade stort för Örjan Kihlström efter en tung löpning senast. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4Östersund (första start 18.30) bjuder på topptävlingar denna onsdagkväll, där det förutom de fyraåriga kallblodens klassiker även blir snabblopp med <strong>Månlykke A.M., Bäcklös Uriel</strong> och <strong>Järvsöodin</strong> i Sven O Perssons Minne.</p>



<p class="wp-block-paragraph">Dessutom kryddas kvällen med fyra Breeders Crown-försök av hög klass. I klassen för treåriga ston möts exempelvis ettan och tvåan från långa E3-finalen för drygt en månad sedan – <strong>Screen Time Limit</strong> (e. Face Time Bourbon) och <strong>Pretty Be Linda</strong> (e. Varenne). Den förstnämnda gör debut för sina nya tränare Daniel Wäjersten.</p>



<p class="wp-block-paragraph">På tal om E3, Joakim Elfvings nybakade tvåa i finalen för hingstar och valacker, <strong>Phantom Express</strong> (e. Readly Express), gör första starten efter E3-silvret som inbringade en miljon.</p>



<p class="wp-block-paragraph">Det mest öppna BC-loppet är annars drabbningen för fyraåriga h/v med Sprintermästartrean <strong>Kuiper</strong> (e. Face Time Bourbon), Kungapokalstrean <strong>Global Etalon</strong> (e. Brillantissime) och Daniel Redéns Derbyhopp <strong>Epic Kronos</strong> (e. Muscle Hill), som vann en avdelning i Margaretas Tidiga Unghästserie på 1.11,5a/2.140 meter i sin senaste start.<br>– Han blev lite förkyld efter senast, men nu har vi tränat på och som tur är hinner vi få in ett lopp så han kommer i form till Derbykvalen. Han känns fin och man ska inte bry sig om att han är väldigt svettig, det har han varit hela sitt liv, det kan vara bra för spelarna att veta. Han kommer kanske inte vara i samma form som senast, men han kommer att vara bra, säger Daniel Redén till Stall Zets hemsida.</p>



<p class="wp-block-paragraph">Det är jackpot på V86 i Östersund med nästan 4,8 miljoner kronor extra i åttarättspotten. </p>



<p class="wp-block-paragraph"><strong>––> Sulkysports spelstuga med viktiga punkter, spikar, drag och favoriter i fara på V86 publiceras som vanligt kl 12.00 idag.</strong></p>



<p class="wp-block-paragraph"><em>Vill du spela V86 tillsammans med Sulkysport hos Andelskungen finns följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/251721_V86_2024-08-07_33_3" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V86 – 15 andelar á 95 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206235_V86_2024-08-07_33_3" target="_blank" rel="noreferrer noopener">Sulkysport V86 UNIK exklusiv – 12 andelar á 150 kr/styck</a></p>



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



<p class="has-drop-cap wp-block-paragraph">5Efter en femteplats i debuten i Frankrike, följt av fyra raka diskvalifikationer, har Jörgen Westholms svenskfödde sexåring <strong>Ninepoints Lasse</strong> (e. Uncle Lasse) verkligen hittat stilen på de franska banorna. Först vann han montéloppet Prix Laura Flessel (€27.000) i Argentan och sedan sulkyloppet Prix de Marmagne (€43.000) på Enghien nio dagar senare. Båda gångerna tillsammans med Alexandre Abrivard.</p>



<p class="wp-block-paragraph">Idag är duon tillbaka i hetluften i sadelloppet Prix Jacques Giboire (€32.000) i Saint-Malo (första start 16.08). Ninepoints Lasse har tjänat minst pengar i loppet och återfinns på startfållan över distansen 2.950 meter tillsammans med bland annat stallkamraten <strong>Made Of Stars</strong> (e. Super Photo Kosmos), som också kommer från seger. Han vann i återkomsten till Frankrike i Prix di Bien-Etre Equin (€24.000) och rids nu av Paul Philippe Ploquin.<br>Fyra hästar finns på startfållan och jagas av sju hästar som startar 25 meter bakom.</p>



<p class="wp-block-paragraph">Är det upplagt för en svensk duell i sulkyloppet Prix du President Maurice de Folleville (€28.000) över 2.950 meter? Maria Törnqvist plockar ut <strong>Fighter Simoni</strong> (e. Orlando Vici) från startfållan. Francois Lagadeuc kör hästen, precis som vid två raka fjärdeplatser i Frankrike. 25 meter bakom startar Markus B Svedberg-tränade <strong>Kimi di Quattro</strong> (e. Maharajah), som vunnit fyra av tio starter i Frankrike och körs av Alexandre Abrivard.</p>



<p class="wp-block-paragraph">Det blir också åttonde avdelningen i franska löpningsserien National du Trot med 90.000 euro i total prispott.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/saint-malo-2024-08-07/" target="_blank" rel="noreferrer noopener">Här är startlistorna till tävlingarna i Saint-Malo.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">6Deltagarna i Åby World Grand Prix på lördag med sex miljoner kronor till vinnaren ska se till att vara på plats på Åby i god tid. Eller rättare sagt senast 22.00 på fredagskvällen. ST har nämligen beslutat att det som i flera andra storlopp ska tillämpas övervakningsstall för deltagarna enligt antidopingreglementet.</p>



<p class="wp-block-paragraph">Om övervakningsstall skriver Svensk Travsport:<br><em>”2020 var första året då övervakningsstall kunde användas under svenska tävlingsdagar i enlighet med Antidopningsreglementet. Det främsta syftet med införandet av övervakningsstall under tävlingar är att öka kontrollen av såväl hästar som utrustning. Genom den ökade säkerheten kan vi arbeta både mot att ingen utomstående kan ta kontakt med de hästar som är uppstallade i övervakningsstallet och att de inte tillförs något, preparat eller annat, som kan påverka prestationen på banan.”</em></p>



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



<p class="has-drop-cap wp-block-paragraph">7Generalrepetitionen Derby-Kenraali (€13.200) inför det finska Derbyt avgörs på huvudstadsbanan Vermo ikväll med 6.000 euro till vinnaren. </p>



<p class="wp-block-paragraph">Det stora namnet är Timo Korvenheimo-tränade <strong>God Hyperion</strong> (e. Brad de Veluwe), som tillsammans med Henri Bollström vann finska Kriteriet i Tammerfors förra året. I år har hästen gjort åtta starter och vunnit hälften av dessa. I senaste starten för drygt två veckor sedan vann han storlopp i Vieremä och besegrade närmast <strong>Sahara Commander</strong> (e. R.C.Royalty), som finns bland motståndarna även ikväll.<br>Loppet avgörs över Derbydistansen 2.620 meter med autostart.</p>



<p class="wp-block-paragraph">Finska Derbykvalen körs på Vermo den 21 augusti, medan den stora finalen avgörs på samma banan lördag den 31 augusti med 120.000 euro till vinnaren.</p>

Fokustema
Morgonsvepet
Läs senare
Dags för svensk segerbukett?
Norsk tuppfäktning mot svenska kallblodsdrottningen. När Alf ångrade segerdoppet. Frode Hamres unika storloppsresultat. V86-jackpot med Breeders Crown-försök. Svenskmöte i Frankrike. Då måste stjärnorna vara på plats på Åby.
Detta och mer i onsdagens ”Sju nyheter vid sju”.
Detta och mer i onsdagens ”Sju nyheter vid sju”.
