
<p class="has-drop-cap wp-block-paragraph">1Den ene vann dubbla Kriterier och Biris Uppfödningslopp. Den andra vann dubbla upplagor av Kriteriestoet och Oaks. Att Frode Hamres <strong>Overvik Prinsen</strong> (e. Will Prinsen) och Jan-Olov Perssons <strong>Majblomster</strong> (e. Tekno Odin) var kungen och drottningen som treåringar råder inga tvivel om.</p>



<p class="wp-block-paragraph">Ikväll väntar en av årets allra viktigaste uppgifter, uttagningslopp till Svenskt Kallblodsderby respektive Derbystoet, och duon går in i kvalkvällen i Östersund med helt olika förutsättningar.<br>Majblomster har radat upp segrarna och är obesegrad i fem starter. Overvik Prinsen gör årsdebut!<br>Två tilltänkta starter för den obesegrade, norske kanonen har gått om intet på grund av för få anmälda hästar i loppen och Frode Hamre har stått över att resa till Sverige.<br>– Ja, det är inte optimalt att gå ut så här direkt i viktiga lopp. Han känns fin, men det är klart att jag hade önskat att han skulle ha gått ett lopp eller två inför Östersund. Men så här blev det nu. Vi har varit på banan och gett honom tre banjobb efter 1.28 full väg som snabbast. Vi har tagit det lugnt och snällt med honom, men han har inte missat något. Det är verkligen en toppindivid det här, säger Frode Hamre till Kanal75.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/07/25v64.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till kvällens Derbykval i Östersund.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">2I uttagningsloppen till Svenskt Kallblodskriterium och Kriteriestoet på Dannero i måndags blev det närmast storslam för Öystein Tjomsland som lade beslag på nio av 24 finalplatser. Ikväll är det upp till bevis för fyraåringarna och då är det helt jämnt på förhand – numerärt sett – mellan de båda kallblodsdominanterna Tjomsland och Jan-Olov Persson.</p>



<p class="wp-block-paragraph">Duon har tolv hästar vardera anmälda till uttagningsloppen och står alltså bakom 24 av totalt 57 hästar.</p>



<p class="wp-block-paragraph">Öystein Tjomsland har vunnit Derbyt sex år i rad med kvintetten <strong>Philip Ess, Nordsjö Odin, Havglimt, Tangen Bork, Tangen Minto</strong> och ifjol med <strong>Bore Mikkel</strong> (e. Moe Odin). Nu har han tre hästar i varje försök till Kallblodsderbyt till start.</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">Senaste svenska segern i kallblodens fyraåringsklassiker i Östersund kom 2018 när Jan-Olov Persson-tränade <strong>Stjärnblomster</strong> (e. B.W.Modde) vann Derbystoet tillsammans med Örjan Kihlström. I år är alltså det stora svenska hoppet hennes lillasyster <strong>Majblomster</strong>.</p>



<p class="wp-block-paragraph">På stosidan kvalar 26 hästar, medan 31 hingstar/valacker jagar finalplats till Svenskt Kallblodsderby.</p>



<p class="wp-block-paragraph"><strong>Tränare med två eller fler hästar i kvalen:</strong><br><em>Tränare, hemmabana – Totalt (h/v – ston)</em></p>



<ul class="wp-block-list">
<li>Jan-Olov Persson, Hagmyren – 12 (7-5)</li>



<li>Öystein Tjomsland, Bergsåker – 12 (9-3)</li>



<li>Wiktor Kylin-Blom, Hagmyren – 3 (2-1)</li>



<li>Geir Flåten, Norge – 2 (2-0)</li>



<li>Kajsa Frick, Rättvik – 2 (1-1)</li>



<li>Robert Skoglund, Bergsåker – 2 (1-1)</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">3Östersund (första start 18.20) är förstås torsdagens huvudbana på svensk mark och de tre försöken till Svenskt Kallblodsderby, samt ett av tre till Derbystoet, tar plats på V65-kupongen. Där spetsas sexrättspotten med drygt 800.000 kronor i jackpotpengar.</p>



<p class="wp-block-paragraph">I övrigt idag då? Arvika (start 12.20) är först ut med lunchtävlingar när värmlandsbanan har sin andra tävlingsdag av tre under årets säsong. Hästägareföreningens Silverpris bjuder 30.000 kronor i förstapris. <br>Magnus Jakobsson plockar ut stoet <strong>Fossens Wilma</strong> (e. S.J.’s Caviar), som visat god form,men enda årssegern har kommit i breddlopp. Nu finns chansen till en större prischeck i spårtrappan, där hon har spår sex bakom bilen.</p>



<p class="wp-block-paragraph">Breddlopp är det däremot som gäller i Boden (start 17.45), men en häst med 2.700 startpoäng dyker upp i ett lopp. Det handlar om Roger Nilsson-tränade kallblodet <strong>Sjöli Morten</strong> (e. Dotterud Teddy), som på 17 starter i livet vunnit åtta och aldrig varit sämre än trea.<br>Vissa breddlopp för kallblod öppnas för hästar över 500 poäng, som istället belastas med 20 meters tillägg och så är fallet för Sjöli Morten när han körs av Nils Westerberg.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/07/240725.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till torsdagens 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/2023/05/hohneck5-1-617x333.jpg" alt="" class="wp-image-449949"/><figcaption class="wp-element-caption">2023 års Elitloppsvinnare Hohneck. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4Högst 100 ston får franska avelshingstar betäcka i hemlandet, men till den summan läggs betäckningar av utlandsregistrerade ston. Till exempel betäcks många svenska ston i Frankrike med franska hingstar innan avkommorna registreras i Sverige.</p>



<p class="wp-block-paragraph">Hetast på marknaden till och med den 14 juli är fjolårets Elitloppsvinnare <strong>Hohneck</strong> (e. Royal Dream), som förutom maximala 100 franska ston även betäckte 83 utländska. Med 183 ston totalt straffade han sin notering från förra året på 148 ston. Det rapporterar 24 Au Trot i en sammanställning över avelssäsongen så här långt.</p>



<p class="wp-block-paragraph">2024 var också första året utan <strong>Ready Cash</strong> i avelsboxen, då han gick bort under fjolåret. Hans påverkan av den franska aveln är fortsatt enorm. Han hade 35 söner i avel som tillsammans betäckte drygt 2.600 ston. 22 sönsöner betäckte nästan 1.400 ston, vilket ger cirka 4.000 betäckningar med Ready Cash på fädernet.</p>



<p class="wp-block-paragraph">Närmare 13.000 betäckningar har rapporterats in till det franska förbundet hittills, en siffra jämförbar med den från samma tid förra året. Ett litet antal betäckningar tillkommer.</p>



<h2 class="wp-block-heading">Flest betäckta son av franska hingstar</h2>



<p class="wp-block-paragraph"><em>Hingst (far) – Betäcka ston (2023)</em></p>



<ol class="wp-block-list">
<li>Hohneck (e. Royal Dream) – 183 (148)</li>



<li>Idao de Tillard (e. Severino) – 160 (112)</li>



<li>Face Time Bourbon (e. Ready Cash) – 152 (154)</li>



<li>Italiano Vero (e. Ready Cash) – 123 (138)</li>



<li>Bird Parker (e. Ready Cash) – 120 (123)</li>



<li>Just A Gigolo (e. Boccador de Simm) – 119 (144)</li>



<li>Krack Time Atout (e. Face Time Bourbon) – 113 (ny)</li>



<li>Fabulous Wood (e. Ready Cash) – 113 (123)</li>



<li>Boccador de Simm (e. Rieussec) – 112 (123)</li>



<li>Brillantissime (e. Ready Cash) – 111 (113)</li>
</ol>



<p class="wp-block-paragraph"><em>Siffrorna gäller både franska och utländska ston.</em></p>



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



<p class="has-drop-cap wp-block-paragraph">5Jägersro dukar upp till sin magiska Åbergskväll på tisdag och det finns gott om godbitar i startlistorna vid sidan om huvudloppet Hugo Åbergs Memorial – läs mer här!</p>



<p class="wp-block-paragraph">I fyraåringsloppet blir det ett möte mellan fjolåets italienske Derbyvinnare och E3-vinnare <strong>Expo Wise As</strong> (e. Ready Cash) och den nybakade Sprintermästaren <strong>Crown</strong> (e. Chapter Seven). Loppet spetsas med vinnaren av Fyraåringseliten, tillika dubbla Grupp I-tvåan <strong>Devilish Hill</strong> (e. Muscle Hill), och fjolårets Hambletonian-femma <strong>Point of Perfect </strong>(e. Walner). Hemmafärgerna försvaras av Drottningpokalvinnaren <strong>Karaboudjan</strong> (e. Walner).</p>



<p class="wp-block-paragraph">Dubbla finaler i Breeders Course för treåringar över sprinterdistans ser bland annat Alessandro Gocciadoros <strong>Fellow Wise As</strong> (e. Maharajah), som vann Treåringseliten på Solvalla.</p>



<p class="wp-block-paragraph">I stayerloppet Malmö Stads Pris är <strong>Coquaholy</strong> (e. Orlando Vici) tillbaka på svensk mark och i Tomas Malmqvists regi, efter att ha vunnit två lopp på fransk mark under försommaren i regi Erik Bondo.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/07/30v75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Jägersros Åbergskväll med V75.</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/01/idaodetillardcldm240128adamstromstalltz-1-617x385.jpg" alt="" class="wp-image-546775"/><figcaption class="wp-element-caption">Prix d&#8217;Amérique-vinnaren Idao de Tillard. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6Efter startgaloppen och sjätteplatsen i Elitloppsförsöket slutade årets Prix d’Amérique-vinnare <strong>Idao de Tillard</strong> (e. Severino) tvåa bakom Horsy Dream i Prix de Washington i midsomras. Numera har hingsten sommarvila, men i augusti drar träning igång igen och första målet är utstakat: Grand Prix de Wallonie (€180.000) i belgiska Mons den 23 september.<br>– Han joggar just nu och kommer att vara tillbaka i full träning i augusti, säger tränaren Thierry Duvaldestin till Paris-Turf.</p>



<p class="wp-block-paragraph">Loppet är det sista i UET:s löpningsserie med final på Vincennes den 11 oktober. Förra årets final avgjordes på Solvalla med Hohneck som vinnare.</p>



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



<p class="has-drop-cap wp-block-paragraph">775 starter (19-10-13) och 11.793805 kronor insprunget har det blivit hittills. Nu hoppas ägaren och uppfödaren Jan Lyng på en sista start – i Åby World Grand Prix – för <strong>Moni Viking</strong> (e. Maharajah).</p>



<p class="wp-block-paragraph">Hingsten har tillbringat sommaren på Överby Stuteri söder om Östersund för avelsarbete och gjorde ett framträdande på tävlingsbanan. Med ägare Lyng i vagnen vann Nils Arne Eggens Minneslopp på Orkla och besegrade närmast <strong>Oracle Tile</strong> (e. Ready Cash), som vann Axevallalöpningen i lördags och därmed fick en biljett till Åbys mångmiljonlopp den 10 augusti.</p>



<p class="wp-block-paragraph">Där vill Jan Lyng att Moni Viking ska vara med.<br>– Det är planen, så jag hoppas på en plats. Min häst har verkligen i loppet att göra. Jag körde honom i söndags och han är i fas. Åby World Grand Prix blir, om vi kommer med, troligen sista loppet i karriären. Moni Viking har varit så bra, så efter loppet ska han få fullt fokus på avel. Det har han förtjänat, sade Jan Lyng till Trav- og Galopp-Nytt.</p>



<p class="wp-block-paragraph">Åtta av tolv platser är tillsatta till Åbys storlopp över 3.140 meter med autostart.</p>



<h2 class="wp-block-heading">Klara för Åby World Grand Prix</h2>



<p class="wp-block-paragraph"><em>Häst (far) – Tränare</em></p>



<ul class="wp-block-list">
<li>Banderas Bi (e. Ganymede) – Alessandro Gocciadoro, Solvalla</li>



<li>Barack Face (e. Ready Cash) – Adrian Kolgjini, Jägersro</li>



<li>Francesco Zet (e. Father Patrick) – Daniel Redén, Solvalla</li>



<li>High On Pepper (e. Ready Cash) – Katjha Melkko, Solvalla</li>



<li>Horsy Dream (e. Scipion du Goutier) – Pierre Belloche, Frankrike</li>



<li>Oracle Tile (e. Ready Cash) – Kristian Malmin, Norge</li>



<li>San Moteur (e. Panne de Moteur) – Björn Goop, Färjestad</li>



<li>Önas Prince (e. Chocolatier) – Per Nordström, Jägersro</li>
</ul>

Fokustema
Morgonsvepet
Läs senare
”Inte optimalt att gå ut direkt”
Obesegrad årsdebuterar i Derbykval. Majblomster ska bryta lång svit. Elitloppsvinnare hetaste franske avelshingsten. Här är hela Åbergskvällen. Planen för Prix d'Amérique-vinnaren. Avslutar karriären på Åby?
Detta och mer i torsdagens ”Sju nyheter vid sju”.
Detta och mer i torsdagens ”Sju nyheter vid sju”.
