
<p class="has-drop-cap wp-block-paragraph">1På Jägersros Åbergskväll om prick två veckor blir det dubbla finaler i Breeders Course för treåringar över sprinterdistans med en halv miljon kronor i förstapris i varje. Efter försök på Solvalla och i Turin är det ikväll på Jägersro (första start 18.20) sista chansen att säkra en biljett på egen hand.</p>



<p class="wp-block-paragraph">De två främsta i försöken är nämligen direktkvalificerade till final, medan fyra hästar får plats via anmälning och flest startpoäng.</p>



<p class="wp-block-paragraph">Bara fem hästar är med i försöket för hingstar och valacker, där Per Nordströms <strong>Ghirardelli</strong> (e. Googoo Gaagaa) har särklassiga meriter. Vid seger ikväll blir han dessutom miljonär. Hästen är redan inkvalad till finalen som tvåa i försöket på Solvalla för fem veckor sedan.</p>



<p class="wp-block-paragraph">I stoklassen slåss åtta hästar om de två finalbiljetterna. Paul Hagoort har de två rikaste hästarna i fältet med Robin Bakker-körda <strong>Greta Jet</strong> (e. Maharajah). Greta Jet har firat framgångae i Breeders Course tidigare. Hon var tvåa i finalen som tvååring och fyra under Elitloppshelgen över medeldistans.</p>



<p class="wp-block-paragraph"><strong>Här är hästarna som kvalat in hittills:</strong><br><strong>Hingstar/valacker:</strong></p>



<ul class="wp-block-list">
<li><strong>Gaber Gio</strong> (e. Face Time Bourbon) – Alessandro Gocciadoro</li>



<li><strong>Gioiello Roc</strong> (e. Nad Al Sheba) – Filippo Rocca</li>



<li><strong>Fragolino Rosso</strong> (e. Booster Winner) – Paul Hagoort</li>



<li><strong>Ghirardelli</strong> (e. Googoo Gaagaa) – Per Nordström</li>
</ul>



<p class="wp-block-paragraph"><strong>Ston:</strong></p>



<ul class="wp-block-list">
<li><strong>Gaga Lady</strong> (e. Mister J.P.) – Alessandro Gocciadoro</li>



<li><strong>Girlfriend Bi</strong> (e. Propulsion) – Alessandro Gocciadoro</li>



<li><strong>Glamour Queen</strong> (e. Face Time Bourbon) – Alessandro Gocciadoro</li>



<li><strong>Mimosa To Martini</strong> (e. Gimpanzee) – Marcus Schön</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/11/majblomsterfrivollgorm-617x347.jpg" alt="" class="wp-image-659559"/><figcaption class="wp-element-caption">Majblomster och Frivoll Gorm efter triumferna i Derbystoet respektive Svenskt Kallblodsderby i somras. Ikväll möts de på Bergsåker. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Bara sex hästar till start men ett som som lovar väldigt mycket på förhand. På Bergsåker (fösta start 17.45) möts Sveriges snabbaste kallblodssto genom tiderna, <strong>Majblomster</strong> (e. Tekno Odin), fjolårets dubble Derbyvinnare <strong>Frivoll Gorm</strong> (e. Ängsborgen) och segermaskinen <strong>Ulvsåsen</strong> (e. Åsajerven), som tagit två raka efter långt skadeuppehåll.</p>



<p class="wp-block-paragraph">Jan-Olov Persson-tränade Majblomster skrev historia när hon travade 1.19,8a/1.640 meter i Elitkampen och joggade hem Järvsöfaks Minne i senaste starten.<br>Frivoll Gorm har tränats hela tävlingskarriären av Öystein Tjomsland och förutom vinster i Derbyt i både Sverige och Norge, så besegrade han Majblomster i säsongens elfte timme i finalen av Norrlands Elitserie för fyraåringar. Sedan fem veckor tillbaka finns Frivoll Gorm i ny regi och ikväll debuterar han för Jörgen Westholm.</p>



<p class="wp-block-paragraph">Ulvsåsen har hunnit bli nio år, men enbart gjort 34 starter (19-3-2) efter att ha stoppats av flera långa skadeuppehåll. 2023 blev det inte ens någon start och förra sommaren var olyckan framme igen. Men Anders Wallins travare har gjort som vanligt, rest sig och fortsatt raka upp segrar. </p>



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



<p class="has-drop-cap wp-block-paragraph">3Dagens tävlingar inleds i Skellefteå (första start 12.20). Boden-tränade Janita Luttunen har matchat fyraåriga <strong>Nordic Beauti</strong> (e. Readly Express) i tuffa sammanhang i vår och sommar, där de tre senaste starterna har gjort inom rikstoton. Största framgången är tredjeplatsen i ett klass I-försök i Umeå i maj, vilken gav biljett till finalen på Solvalla under Elitloppshelgen.</p>



<p class="wp-block-paragraph">Nu kliver Nordic Beauti ned i klass i ett ”vanligt” lunchlopp och det sker med ny kusk i vagnen. 22-åriga Tilde Eriksson får chansen bakom Nordic Beauti och Tilde ståtar med fem vinster på 48 starter i år, däribland med egentränade Joker Mearas (e. Nuncio) i Boden i torsdags.</p>



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



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



<p class="has-drop-cap wp-block-paragraph">4Tjomslands mästerskap – f’låt Norskt Mästerskap – för kallblod avgörs i två klasser på Sörlandet på lördag med 250.000 kronor till vinnaren i varje. I hingstklassen står Öystein Tjomsland bakom fem av nio deltagare.</p>



<p class="wp-block-paragraph">Som vanligt kör han själv <strong>Brenne Borken</strong> (e. Tangen Bork), som drog nytta av <strong>Stumne Fyrs</strong> (Joker Elden) och <strong>Tangen Borks</strong> (e. Bork Odin) sanslösa öppning i sprinterloppet på Jarlsberg för 1,5 vecka sedan. Då visade klockan 1.12,3 första 500 meterna!<br>Sedan klev Brenne Borken in i matchen och vann plättlätt på 1.19,2a/1.609 meter. Nu är distansen 1.000 meter längre när ett mästerskapsguld står på spel.</p>



<p class="wp-block-paragraph"><strong>Startlista Norskt Mästerskap, kallblod h/v</strong><br>2.609 meter autostart, Sörlandet lördag<br><em>Häst – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Grisle Odin G.L. – Åsbjörn Tengsareid (Öystein Tjomsland)</li>



<li>Grisle Tore G.L. – Per Vatle Kals</li>



<li>Grislesfaksen G.L. – Vidar Tjomsland (Öystein Tjomsland)</li>



<li>Smedheim Braut – Eirik Höitomt (Öystein Tjomsland)</li>



<li>Tangen Bork – Tom Erik Solberg (Öystein Tjomsland)</li>



<li>Stumne Fyr – Ole Johan Östre (Merete Viksås)</li>



<li>Brenne Borken – Öystein Tjomsland</li>



<li>Idu Bork – Tom Erga</li>



<li>Ådne Odin – Svein Ove Wassberg (Kristoffer Lunde Malme)</li>
</ol>



<p class="wp-block-paragraph">I stoklassen är det fullt fält och tolv hästar bakom startbilen. En av dessa är <strong>Voje Lotta</strong> (e. Ängsborken), som besegrade Majblomster och vann norska Stoderbyt i höstas. I år har det blivit fem vinster på sju försök.</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/02/france3-617x423.jpg" alt="" class="wp-image-409605"/><figcaption class="wp-element-caption">Ampia Mede Sm och Franck Nivard spurtade hem Prix de France 2023. Foto: Gerard Forni</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5I våras avslutade italienskan <strong>Ampia Mede Sm</strong> (e. Ganymede-Polimpia Slide Sm), 1.09,6am/€1.631.896, sin karriär i Gran Premio della Lotteria i Neapel. Nu har toppstoet med segrar i Prix de France, Prix de Paris och en andraplats i Prix d’Amérique gått till avel. Hon är konstaterat dräktig med Face Time Bourbon på Haras d’Ecouché i Orne. </p>



<p class="wp-block-paragraph">Ampia Mede Sm är det vinstrikaste italienskfödda stoet genom tiderna med 1.631.896 intjänade euro. Bakom henne följer <strong>Lisa America</strong> och <strong>Lana del Rio</strong> med 1.523.041 respektive 1.422.909 euro. Över en miljon euro/dollar har också <strong>Ilaria Jet</strong> och <strong>Lantern Kronos</strong> tjänat.</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/2025/07/globalattentionletrot-617x333.jpg" alt="" class="wp-image-743445"/><figcaption class="wp-element-caption">Jimmy Dahlman-tränade Global Attention slog till på gräsbanan i Frankrike. Skärmbild Letrot</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6Igår firade fransmännen nationaldag – Bastiljdagen – och då kördes och reds travlopp på 14 banor runt om i landet.</p>



<p class="wp-block-paragraph">Fast svenskar kunde också fira, framför allt Gävletränaren Jimmy Dahlman som sände ned svenskföddenioåringen <strong>Global Attention</strong> (e. Love You) till Frankrike i höstas. En andra- och en tredjeplats hade det blivit på sju försök i Frankrike, men på gräsbanan i Savenay nära Nantes i västra Frankrike blev det succé.</p>



<p class="wp-block-paragraph">Gerald Blandin satt i sulkyn bakom den svenske travaren i Prix de Cordemais (€20.000) över 3.100 meter i högervarv. Global Attention var snabbast från början me släppte ledning efter första sväng på 1.150-metersbanan. Efter ytterligare ledarskifte satt hästen fastlåst i tredje invändigt. <br>Det var långt fram till täten, men in på upploppet vred Blandin ut svensken fem spår och via en rykande avslutning hann Global Attention fram till seger, värd 9.000 euro.</p>



<p class="wp-block-paragraph">Segern var även tränare Dahlmans första på fransk mark.</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/2025/07/spitforspatfolcaptaincorey-617x486.jpeg" alt="" class="wp-image-743449"/><figcaption class="wp-element-caption">Spit For Spat och hennes stoföl med Captain Corey som pappa. Foto Privat</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">7Alf Nordemo-ägda <strong>Spit For Spat</strong> (e. Explosive Matter), 1.12,1ak/300.553 kr, har blivit mamma till ett stoföl med Hambletonianvinnaren Captain Corey som pappa på Haras de Sou. Spit For Spat är nu dräktig med Donato Hanover.</p>



<p class="wp-block-paragraph">Spit For Spat vann ett lopp i USA och ytterligare tre i Sverige sedan hon inhandlats i Harrisburg. Hon ingår i samma syskonskara som<strong> Fiji</strong> (e. Cantab Hall), 1.10,6/$324.028, <strong>Itsgoodtobequeen</strong> (e. Muscle Massive), 1.10,7*/160.668, och <strong>McMatters</strong> (e. Explosive Matter), 1.10,0/$141.917.</p>



<p class="wp-block-paragraph">Modern <strong>Ucalthisahoneymoon</strong> (e. Yankee Glide), 1.12,8/$11.592, är helsyster med <strong>Falls For You</strong>, 1.09,7/$1.326.537, som bland annat tog hem Goldsmith Maid, Kentucky Futurity Filly och Armbro Flight Stakes.</p>



<p class="wp-block-paragraph">Ni vet väl att ni kan maila in fölrapporter för fri publicering? <a href="mailto:claes@sulkysport.se">Maila till Sulkysport</a></p>

Fokustema
Sju nyheter vid sju
Läs senare
Finalklar – och kvalar igen
De jagar plats till Åbergskvällen. Toppkallblod möts på Bergsåker. Tjomslands mästerskap om 250.000 kronor. Stjärnsto bekräftat dräktigt. Gävletränare etta i Frankrike.
Detta och mer bland tisdagens nyheter.
Detta och mer bland tisdagens nyheter.
