
<p class="has-drop-cap">1<strong>Bäcklös Uriel</strong> (e. Smedheim Solan) var kometen i kallblodseliten förra året och blev näst snabbaste svenska kallblod genom tiderna när han utklassningsvann på 1.18,7a/1.640 meter i Bollnäs i somras. Bara självaste <strong>Järvsöfaks</strong> har har haft bättre segertider av svenska kallblod genom tiderna! Han travade 1.17,9 vid det historiska världsrekordet i Gävle 2005 och noterade 1.18,4 på milebanan i Tingsryd två år senare. <br>Det var höjdpunkten under en mycket stark sjuåringssäsong för Bäcklös Uriel, som vann Svenskt Kallblodskriterium 2019. Totalt blev det 16 starter (10-0-3) och 1.167.517 kr, för hästen som tränades av uppfödaren och ägaren Nicklas Blom under unghästsäsongerna.</p>



<p>När Bäcklös Uriel kliver in i en ny säsong gör han det med stora förväntningar på sig och ett givet största mål: Elitkampen på Solvalla sista söndagen i maj. Första stegen dit tas i Lassas Lavins minne på Hagmyren (första start 13.45) idag, där Jan-Olov Perssons stjärna dragit spår ett bakom bilen över medeldistans.<br>Bland motståndarna finns exempelvis fem stallkamrater och duon <strong>Tekno Jerven</strong> (e. Tekno Odin) och <strong>Philip Ess</strong> (e. Briskeby Philip) från Öystein Tjomslands stall.</p>



<p><strong>Bästa segertider av svenska kallblod:</strong></p>



<ol class="wp-block-list">
<li>1.17,9a – Järvsöfaks (e. Trollfaks) – Gävle 12 juli 2005</li>



<li>1.18,4a – Järvsöfaks (e. Trollfaks) – Tingsryd 12 augusti 2007</li>



<li>1.18,7a – Järvsöfaks (e. Trollfaks) – Eskilstuna 13 september 2003</li>



<li>1.18,7a – Bäcklös Uriel (e. Smedheim Solan) – Bollnäs 16 juni 2023</li>



<li>1.18,8a – Järvsöfaks (e. Trollfaks) – Färjestad 24 setember 2005</li>
</ol>



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



<p class="has-drop-cap">2Det blir fokus på kallbloden på Hagmyren idag, där det blir dubbla försök till fyraåringsserien Sleipner Cup med finaler i juni. I stoklassen, som är placerad utanför Grand Slam 75-kupongen, dyker nämligen drottningen <strong>Majblomster</strong> (e. Tekno Odin) upp på banan för första gången sedan hon fullbordade en närmast fläckfri treåringssäsong med seger i Oaks på Momarken i oktober.<br>Nu ställs siktet mot Derbystoet med final i Östersund den 7 augusti och norska Stoderbyt, som avgörs på Bjerke lördag den 7 september. I eftermiddagens försök i Sleipner Cup har Majblomster tjänat lika mycket som hennes nio konkurrenter gjort – tillsammans. </p>



<p>Försöket för hingstar och valacker ser exempelvis svenska kullens vinstrikaste häst förra året, Tierpamatören Carl-Gustav Anderssons segermaskin <strong>Guldhagens Pirat</strong> (e. Ingbest), som vann fem av tio starter och nu har årsdebuten avklarad.</p>



<p>Travsöndagen på svensk mark inleds med lunchtävlingar av breddloppsformat på Jägersro (första start 12.20).</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/04/240414.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till söndagens tävlingar.</a></p>



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



<p class="has-drop-cap">3För andra söndagen i följd avgörs det Grupp-lopp i italienska Turin (första start kl. 14.45).</p>



<p>Det handlar om hingst samt stoklass av Gran Premio Citta&#8217; di Torino (€66.000) för fyraåringar med flera Sverigebekanta namn i startlistorna.</p>



<p>I stoklassen gör fjolårets Breeders Course-vinnare <strong>Esmeralda Bez </strong>(e. Maharajah) sin andra start för året i lag med Alessandro Gocciadoro i hingstklassen möts Gocciadoros Orsi Mangelli-tvåa <strong>Edy Girifalco Gio</strong> (e. Victor Gio) samt Sabato Bevilacquas derbytvåa <strong>Ector Francis</strong> (e. Nad Al Sheba).</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/esmeraldabez-617x333.jpg" alt="" class="wp-image-452521"/><figcaption class="wp-element-caption">Esmeralda Bez och Alessandro Gocciadoro vann Breeders Course för treåriga ston ifjol med 600.000 kronor i förstapris. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Noterbart är även att den forne, svenska derbyfinalisten <strong>Kennedy</strong> (e. Joke Face) gör debut i Alessandro Gocciadoros regi. Italienaren väljer själv att köra nioåringen före fjolårets Prins Carl Philips Jubiluemspokal-vinnare <strong>Jimmy Ferro B.R.</strong> (e. Love You) som istället får Federico Esposito bakom sig.</p>



<p><a href="https://ippica.snai.it/partenti/T/IT44/2024-04-14?signature=a6aae45ba2b578cffbb760f614ea832c6c349f25948a231311011f04195bfe89" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna i Turin.</a></p>



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



<p class="has-drop-cap">4Efter att vunnit ett försök till Breeders Course för tvååringar på 1.13,9a/1.640 meter i januari gjordes <strong>Follow Him</strong> (e. Father Patrick) till favorit i den efterföljande finalen, men där blev det galopp.</p>



<p>Under vintern flyttades hästen från Henrik Hollsten till Steen Juul och idag gör superlöftet debut på dansk mark vid eftermiddagens tävlingar på Charlottenlund (första start kl. 14.00).</p>



<p>Den danske mästertränaren luftar hästen mot äldre konkurrenter i ett lopp över 2.000 meter autostart med ynka 8.500 danska kronor i segerpremie.<br>Under tävlingsdagen gör även fjolårets danska Sprintermästarvinnare <strong>Thewinnertakesitall</strong> (e. Muscle Hill) årsdebut i ett flerklasslopp liksom 2022 års danska Uppfödningsloppsvinnare<strong> Isabella C N </strong>(e. Dream Vacation).</p>



<p><a href="https://www.epaper.dk/danskhv/charlottenlund/lunden_14-04-24/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna på Charlottenlund.</a></p>



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



<p class="has-drop-cap">5Suur-Hollolan Best Lady (€22.000) var lördagens höjdpunkt i finländska Lahti och där gick segern till Love You-dottern <strong>El Indeed</strong>, körd av Hannu Torvinen.</p>



<p>Från spår åtta bakom bilen tog det 600 meter innan Elina Laakkonens sto hade nått taktpinnen och det satte sina spår i slutskedet, men El Indeed höll emot med hals som marginal gentemot Velvet Gold (e. Maharajah) medan det var en längd ner till trean Sahara True Lies (e. Make it Happen).</p>



<p>Triumfen värd 10.000 euro togs på 1.14,0a/2.100 meter och stoets näst största seger i karriären efter att vunnit en final inom Stodivisionen under fjolåret.</p>



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



<p class="has-drop-cap">6Björn Goop har räknat hem ett noterbart nyförvärv med påtaglig segeraptit.<br>Det handlar om den sjuårige, tyskfödde hingsten <strong>Venture Capital</strong> (e. Broad Bahn) 1.11,6ak/722.926 kr som vunnit 15 av karriärens 21 starter och där ibland försök samt final av Klass II under Elitloppsmeetinget år 2021.</p>



<p>Då tränades hästen av Wolfgang Nimczyk och spåddes en lysande framtid, men gjorde blott fyra starter därefter innan han nu varit osynlig i tävlingssammanhang sedan en fjärdeplats i ett V75-lopp under Åbergskvällen år 2022.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/05/venturecapital1-617x333.jpg" alt="" class="wp-image-169821"/><figcaption class="wp-element-caption">Venture Capital vann Klass II-final på Solvalla under Elitloppshelgen år 2021. Foto: Mathias Hedlund.</figcaption></figure>



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



<p class="has-drop-cap">7Fjolårets Derbyfinalist <strong>Esposito</strong> (e. Villiam) 1.11,5ak/1.030.000 kr ser ut att missa resterande del av den säsong som inletts så lovande.</p>



<p>Den av Timo Nurmos-tränade hästen började året med att vinna final av Solvallaserien samt dubbla försök i Bronsdivisionen, men fick nöja sig med en femteplats i finalen.</p>



<p>Delägaren Lasse Grankvist lämnade beskedet i Travpodden.<br>– <em>Han är skadad nu. En hovspricka. Så han blir borta lång tid, troligtvis resten av året, så det är synd</em>, sade Grankvist i podden.</p>

Fokustema
Morgonsvepet
Läs senare
Elitkampen i sikte
Om en kallblodstopp som gör årsdebut, ny storloppsdag i Turin och en minnesvärd Klass II-finalsvinnare som är tillbaka på svensk mark efter lång frånvaro går bland annat att läsa i veckans sista morgonsvep.
