
<p class="has-drop-cap wp-block-paragraph">1Han vinner flest lopp av alla svenska kuskar och flest kallblodslopp. Ikväll på hemmabanan Hagmyren (första start 18.20) kan Mats E Djuse fylla på rejält i båda ligorna. Det körs nämligen enbart kallblodslopp på fredagskvällens huvudbana på svensk mark.</p>



<p class="wp-block-paragraph">Och Djuse sitter på en hel del vassa segerchanser på förhand. Den allra bästa är bakom fyraåriga kulldrottningen <strong>Majblomster</strong> (e. Tekno Odin), som i Hagmyrens fyraåringspris för ston med 100.000 kronor till vinnaren genrepar inför kvalen till Derbystoet i Östersund om knappt tre veckor, den 25 juli.<br>Mats kör exempelvis även tidernas näst snabbaste svenska kallblod, <strong>Bäcklös Uriel</strong> (e. Smedheim Solan), i Sleipners Elitlopp över passande 1.640 meter med bilstart.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/04/majblomsters8i8871-617x333.jpg" alt="" class="wp-image-569581"/><figcaption class="wp-element-caption">Majblomster och Mats E Djuse. Foto Anders Kongsrud/hesteguiden.com</figcaption></figure>



<p class="wp-block-paragraph"><strong>Segerrikaste kuskar i kallblodslopp i Sverige:</strong><br><em>Kusk, hemmabana – Resultat – Inkört</em></p>



<ol class="wp-block-list">
<li>Mats E Djuse, Hagmyren – 208 st: 47-34-26 – 3.621.500 kr</li>



<li>Ulf Ohlsson, Solvalla – 149 st: 29-17-14 – 2.071.500 kr</li>



<li>Marcus Lilius, Hagmyren – 152 st: 23-20-10 – 1.904.400 kr</li>



<li>Per Linderoth, Östersund – 86 st: 11-9-8 – 1.135.500 kr</li>



<li>Magnus A Djuse, Solvalla – 62 st: 11-6-6 – 1.308.600 kr</li>



<li>Oskar Kylin Blom, Gävle – 70 st: 11-6-5 – 806.400 kr</li>
</ol>



<p class="wp-block-paragraph"><em>Statistik gäller starter på svenska banor per den 3 juli.</em></p>



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



<p class="has-drop-cap wp-block-paragraph">2Den 19 oktober 2020 fick den störste i svensk kallblodssport somna in. Åldern hade tagit ut sin rätt när <strong>Järvsöfaks</strong> lämnade jordelivet 26 år gammal. Han hyllades ack så många gånger såväl under som efter sin aktiva karriär, där han blev en ambassadör både för kallblodssporten och travsport i stort.</p>



<p class="wp-block-paragraph">Att Järvsöfaks minne ska hedras på hemmabanan Hagmyren är förstås självklart och från 2021 har femåringsloppet Linje 5 blivit Linje 56 – Järvsöfaks Minne och även öppnats för sexåringar hästar.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2018/01/jrvsfaksihagen-617x288.jpg" alt="Sulkysport, Travsport, Trav, Häst, Järvsöfaks" class="wp-image-17802"/><figcaption class="wp-element-caption">Järvsöfaks. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Det är kvällens högst doterade lopp på Järvsöfaks gamla hemmabana och bjuder 125.000 kronor till vinnaren. Sedan sexåringarna fick chansen i loppet har fortfarande ingen klarat av att vinna. Vinnarna har nämligen varit femåringarna <strong>Nordsjö Odin</strong> (e. Tekno Odin), <strong>Oppgårdsdrängen</strong> (e. Tekno Odin) och ifjol <strong>Brenne</strong> <strong>Odin</strong> (e. Moe Odin).<br>Om en femåring vinner även årets upplaga är segertränaren redan klar. Jan-Olov Persson tränar samtliga tre ungdomar i loppet: <strong>Brolin</strong> (e. Lome Brage), <strong>Juni Blixt</strong> (e. Tekno Odin) och <strong>Envis</strong> (e. Lome Brage). Noterbart är att både Brolin och Envis helt saknar Järvsöfaks i stamtavlan, medan avelsmatadoren är morfar till Juni Blixt.</p>



<p class="wp-block-paragraph">Järvsöfaks mest framgångsrike hyllas också med ett eget lopp. <strong>Hallsta Lotus</strong> lopp är ett försök-finallopp där försöken avgörs över sprinterdistans med startbil och finalen över medeldistans med sju hästar på två volter.  </p>



<p class="wp-block-paragraph">Hallsta Lotus, som lämnade jordelivet hösten 2020, tillhör första kullen från Sveriges största kallblod genom tiderna och i historiken är han tvåa av alla svenska kallblod bakom sin pappa. Hallsta Lotus gjorde 195 starter, vann 75 av dessa och tjänade hela 10.015.436 kronor. I regi Jan-Olov Persson vann han Svenskt Kallblodsderby och som äldre i princip allt som går att vinna under totalt 13 (!) säsonger på tävlingsbanan.</p>



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



<p class="has-drop-cap wp-block-paragraph">3Förra året blev John Östman först ut bland Sveriges banchampions när han tog titeln i Lycksele. Vid dagens lunchtävlingar (första start 12.20) kan det bli repris. Umåkerproffset leder nämligen körsvensligan när Lyckseles tredagarsmeeting ska gå i mål efter en intensiv vecka.<br>Östman toppar kuskligan med tre segrar, en mer än Stefan Edin och William Strand, och sitter med trumf på hand när han kör sju av åtta lopp idag. Edin har tre uppsittningar och Strand fyra.</p>



<p class="wp-block-paragraph">Finalen av Kallblodspokalen avgörs med 40.000 kronor till vinnaren. De två försöken kördes förra fredagen och vanns av <strong>Lia Lykke</strong> (e. Lome Brage) och <strong>Per Jo</strong> (e. Klack Jo).<br>Dagens mest meriterade besökare på den fyrbenta sidan är annars snabbloppsräven och flerdaldige gulddivisionsvinnaren <strong>From The Mine</strong> (e. From Above). Hästen har hunnit bli tolv år, men tävlingsviljan är det inget fel på med en seger på två försök 2024.</p>



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



<p class="has-drop-cap wp-block-paragraph">4Samtidigt som en bana slår igen för säsongen öppnar en annan. Wermlands Trafvarsällskap är Sveriges äldsta och grundades redan 1882. Hemvisten sedan 1950-talet är Arvikatravet. Ikväll (första start 18.30) drar 2024 års säsong igång på 800-metersbanan.</p>



<p class="wp-block-paragraph">Sedan 2015 har det varit fyra tävlingsdagar i Arvika, men i år blir det bara tre. Den stora tävlingsdagen är avslutningen med lunchtävlingar fredag den 2 augusti. Då bjuds 40.000 kronor i förstapris i fem lopp och höjdpunkten Arvikas Jubileumslopp för hägsta klassen över sprinterdistans har en segercheck på 50.000 kronor.<br>– Arvikatravet har i år gjort en satsning så att inget av våra travdagars lopp har mindre än 25.000 i förstapris då vi tycker att sportens aktiva är värda en satsning på anständigt förstapris, skriver styrelsen i programmet till dagens tävlingar.</p>



<p class="wp-block-paragraph">Björn Goop blev kuskchampion förra året, men tävlar inte i årets premiär. Det gör däremot hans fyraåriga Muscle Hill-dotter <strong>Karusell</strong> som vunnit hälften av livets starter och nu får Peter Zadel i sulkyn.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/07/240705.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/07/geirvegardgundersen-617x333.jpg" alt="" class="wp-image-604194"/><figcaption class="wp-element-caption">Geir Vegard Gundersen. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5Igår avgjordes Sprintermästaren i Halmstad. Ikväll på Jarlsberg är det dags för den norska upplagan, men på grund av svalt intresse och blott nio anmälda till klassikern frös naturligtvis försöken inne och fyraåringarna gör upp direkt i finalen.</p>



<p class="wp-block-paragraph">Kullens dominant finns med, Geir Vegard Gundersen-tränade <strong>Just Like Heaven</strong> (e. Maharajah). Denne vann norska Kriteriet och Prinsesse Märtha Louises Pokallopp förra året och har åtta segrar och två andrapris hittills i karriären.</p>



<p class="wp-block-paragraph"><strong>Startlista Jarlsberg Grand Prix</strong><br><em>1.609 meter autostart, förstapris: 340.000 norska kr:</em></p>



<ol class="wp-block-list">
<li><strong>Shahjahan T.H.</strong> (e. Maharajah) – Dag-Sveinung Dalen</li>



<li><strong>Klinger</strong> (e. Maharajah) – Ole Johan Östre</li>



<li><strong>Googooman</strong> (e. Googoo Gaagaa) – Jomar Blekkan</li>



<li><strong>Just Like Heaven</strong> (e. Maharajah) – Magnus Teien Gundersen</li>



<li><strong>The Bandit</strong> (e. Lionel) – Göran Antonsen</li>



<li><strong>Jazzman</strong> (e. Muscle Massive) – Per Oleg Midtfjeld</li>



<li><strong>Powwow</strong> (e. Papagayo E.) – Lars Anvar Kolle</li>



<li><strong>Nelson Daytona</strong> (e. Father Patrick) – Tom Erik Solberg</li>



<li><strong>Charron</strong> (e. Code Bon) – Geir Vegard Gundersen</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">6En amatörmatch mellan Frankrike och Sverige hålls i Cabourg ikväll (kl. 22.11) och från Sverige deltar kvartetten Karl Iikio, Alf Nordemo, Jesper von Krusenstierna och Rolf Odén. Det handlar om Prix Unat Recontre France-Suede (€6.000) för äldre travare över distansen 2.725 meter.</p>



<p class="wp-block-paragraph">Alf Nordemo sitter upp bakom Ron Kuiper-tränade och egenägde <strong>Galiano du Bocage</strong> (e. Singalo). Jesper von Krusenstierna kör Stéphane Provoosts <strong>Ioup la Boum</strong> (e. Very Pleasant), Rolf Odén tar hand om tömmarna bakom Thierry Duvaldestin-tränade och svenskfödde <strong>Mister Invictus</strong> (e. Ready Cash), medan Karl Aikio kör <strong>Gazou Piquenard</strong> (e. Rolling d’Heripre) åt Franck Terry.</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/06/kungfufighting-617x412.jpg" alt="" class="wp-image-598581"/><figcaption class="wp-element-caption">Kungfufighting vann sitt försök från dödens för Jan Dahlgaard. Foto: Kjeld Mikkelsen/K M Photo</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">7Kullens kung bland treåringarna i Danmark jagar en ny storloppstitel i Skive i eftermiddag. Det handlar om Grand Circle 3-årschampionat, där Nuncio-sonen <strong>Kungfufighting</strong> blir stor favorit efter att ha vunnit åtta av livets nio starter, däribland Dansk Uppfödningslöpning i höstas.<br>Hingstar/valacker och ston gör upp i varsin klass och förstapriserna är 187.000 danska kronor, cirka 285.000 svenska. Tränardominanten är Nicklas Korfitsen som har tre hästar i varje final. Själv kör han <strong>Keystone</strong> (e. Wishing Stone) i hingstklassen och <strong>Keep Cool Cash</strong> (e. Vivid Wise As) bland stona.</p>



<p class="wp-block-paragraph">Det svenska bidraget är Jörgen Sjunnesson som sitter upp bakom Henrik Thomsen-tränade hingsten <strong>Kazio</strong> (e. Muscle Massive), som han kör för första gången. Hästen hade fyra raka segrar i år innan han slutade tvåa från ledningen i försöket bakom Karat C N (e. Express Bourbon).</p>



<p class="wp-block-paragraph"><strong>Grand Circle 3-års Championat h/v</strong><br><em>2.060 meter autostart, förstapris 187.000 danska kr:</em></p>



<ol class="wp-block-list">
<li>Karat C N (e. Express Bourbon) – Michael Lönborg</li>



<li>Kermit (e. Varenne) – Jeppe Juel</li>



<li>Kungfufighting (e. Nuncio) – Jan Dahlgaard</li>



<li>Kingston Flamingo (e. Ens Snapshot) – Birger Jörgensen</li>



<li>Kazio (e. Muscle Massive) – Jörgen Sjunnesson</li>



<li>Kingston K (e. From Above) – Morten Friis</li>



<li>Keystone (e. Wishing Stone) – Nicklas Korfitsen</li>



<li>Knud (e. Wishing Stone) – Casper M Nielsen</li>



<li>Kalle May (e. Great Challenger) – Kasper K Andersen</li>



<li>Kill Bill (e. Donato Hanover) – Flemming Jensen</li>



<li>Kombardo Skov (e. Dominion Beach) – Henrik Lönborg</li>



<li>Krakken (e. Broadway Hall) – Kenneth Andersen</li>
</ol>



<p class="wp-block-paragraph"><strong>Grand Circle 3-års Championat ston</strong><br><em>2.060 meter autostart, förstapris 187.000 danska kr:</em></p>



<ol class="wp-block-list">
<li>Know Your Shadow (e. Cantab Hall) – Birger Jörgensen</li>



<li>Keep Cool Cash (e. Vivid Wise As) – Nicklas Korfitsen</li>



<li>Kaley D C (e. Wishing Stone) – Rene Kjaer</li>



<li>Karisma (e. Wishing Stone) – Casper M Nielsen</li>



<li>Karoline Gardenia (e. Great Challenger) – Marc Baek Nielsen</li>



<li>Keeping the Shadow (e. Googoo Gaagaa) – Ken Ecce</li>



<li>Kiwi Shadow (e. Broad Bahn) – Jeppe Juel</li>



<li>Keep Up Laser (e. One Too Many) – Knud Mönster</li>



<li>Karla Vang (e. Wishing Stone) – Flemming Jensen</li>



<li>Kandis Spring (e. Fourth Dimension) – Jan Dahlgaard</li>



<li>Kween Cook (e. Cruzado Dela Noche) – Peter Frandsen</li>



<li>Koningen (e. Great Challenger) – Michael Lönborg</li>
</ol>

Fokustema
Morgonsvepet
Läs senare
Bäst – även med kallblod
Mats vinner flest kallblodslopp – också. Hyllningar till Järvsöfaks och Hallsta Lotus. Östman årets första champion? Landets äldsta travsällskap har premiär. Svenska amatörer i Frankrike. Rumphuggen Sprintermästare.
Detta och mer i fredagens ”Sju nyheter vid sju”.
Detta och mer i fredagens ”Sju nyheter vid sju”.
