
<p class="has-drop-cap wp-block-paragraph">1Avelsföreningens Jubileumslöpning för ston med 100.000 kronor till vinnaren är onsdagens höjdare på svensk mark. Skådeplatsen är Solvalla (första start 18.15) och även om loppen endast lockat sju damer är klassen god.</p>



<p class="wp-block-paragraph">Här finns Stefan Melanders toppsto <strong>Decision Maker </strong>(e. Nuncio), som vunnit åtta av sina tio senaste starterna. Enda plumpen är galoppen i Breeders Crown-finalen i Eskilstuna i höstas och det andra nederlaget kom i snabbloppet mot exempelvis Elitloppshästar som <strong>Missle Hill</strong> (e. Muscle Hill) och <strong>Night Brodde </strong>(e. Up And Quick). Decision Maker besegrade båda dessa, men fick som tvåa ge sig mot stallkamraten <strong>Thereisnolimit</strong> (e. Nuncio).</p>



<p class="wp-block-paragraph">Nu väntar alltså enbart ston i startlistan och speciellt en tuff utmanare i Daniel Redén-tränade <strong>Felicia Zet </strong>(e. Ready Cash), som är näst snabbast av alla ston på svensk mark i år efter att ha travat 1.10,0ak vid andraplatsen bakom <strong>Betting Pacer </strong>(e. Maharajah) på Solvalla för 2,5 veckor sedan.</p>



<p class="wp-block-paragraph">Decision Maker och Felicia Zet har mötts en gång, i stoeliten på Solvalla under Kriteriedagen förra året. Då var Felicia Zet spelad till fyra gånger pengarna på vinnarspelet och slutade trea från ledningen, medan Decision Maker stod i 69 gånger och galopperade i jumboposition på sista bortre långsidan från spår åtta.</p>



<p class="wp-block-paragraph">Tyvärr är det små fält på Solvalla ikväll och två av Solvallaseriens tre försök – nio respektive sju hästar – har placerats utanför V86-kupongen.</p>



<p class="wp-block-paragraph">Det har även ett sexhästarsfält där Per K Eriksson-tränade snackhästen <strong>Lozano di Quattro</strong> (e. Trixton) gör andra starten för året efter att ha lekt hem årsdebuten i mitten av mars.</p>



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



<p class="has-drop-cap wp-block-paragraph">2Medan endast ett av tio lopp på Solvalla är fyllda ikväll, så är motsvarande siffror för den andra saxbanan Jägersro (första start 18.27) fem av nio lopp fullbesatta.</p>



<p class="wp-block-paragraph">Det innebär 12-12-12-15 hästar till start i banans halva V86-kupongen, som bjuder på jackpot och nästan 6,5 miljoner kronor extra i sexrättspotten.</p>



<figure class="wp-block-image alignright size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/02/lahdekorpihannaadam2-617x333.jpg" alt="" class="wp-image-411204"/><figcaption class="wp-element-caption">Hanna Lähdekorpi har en duo till start i kvällens 100.000 kronorslopp på Jägersro. Foto Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Jägersros dubbelklasslopp med 15 hästar hästar i skarven mellan klass I och brons med STL-mått mätt respektive silverdivisionsstatus för tilläggshästarna kan bli rafflande. Johan Untersteiners<strong> Ture L.A.</strong> (e. Maharajah) gör årsdebut efter att ha sprungit in över 400.000 kronor två säsonger i rad. Bland annat vann han silverförsök i höstas när han nu ska försöka plocka in 20 meter på formstarke <strong>Steady Victory</strong> (e. S.J.’s Caviar). </p>



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



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/04/10v86.pdf" class="">Här kan du ta del av dagens startlistor till tävlingarna på Jägersro och Solvalla.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela V86 tillsammans med Sulkysport kan du välja mellan följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/251721_V86_2024-04-10_40_1" class="">Sulkysport Lilla V86 – 15 andelar á 95 kr/styck</a></p>



<p class="wp-block-paragraph"><a class="" href="https://www.atg.se/andelskungen/spel/206235_V86_2024-04-10_40_1">Sulkysport Stora V86 – 15 andelar á 250 kr/styck</a></p>



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



<p class="has-drop-cap wp-block-paragraph">3Onsdagen bjuder på en svensk årspremiär när Årjäng (första start 12.20) slår upp portarna för banans 15 tävlingsdagar långa säsong. Höjdpunkten kommer mitt i sommaren med Årjängs Stora Sprinterlopp och STL-tävlingar lördag den 13 juli.</p>



<p class="wp-block-paragraph">Kanske dyker Årjängs framgångsrikaste häst förra året – och i år – Helena Edlunds Beartime (e. Pastor Stephen) upp i hemmabanans storlopp? Beartime startar på Momarken på lördag. Näst bäst av Årjängstravarna förra året var Paw Mahonys tuffing <strong>Millmighty</strong> (e. Make It Happen), som belönades med 300.000 kronor vid den imponerande segern i Malmö Stads Pris under Åbergskvällen på Jägersro.</p>



<p class="wp-block-paragraph">Nu är det dags för årets första start och Mahony väljer att plocka ut sin topphäst på hemmaplan, där han är mest meriterad av deltagarna i spårtrappan och inleder från spår åtta bakom bilen.</p>



<p class="wp-block-paragraph">En annan intressant hemmahäst är Kristian Lindbergs kallblod <strong>Remlov</strong> (e. Tekno Odin), som inledde tävlingskarriären ifjol med sju raka segrar. Efter att ha avslutat med två fjärdeplatser väntade vinteruppehåll och nu är han tillbaka efter nästan halvårslång paus.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/04/240410.pdf">Här är startlistorna till onsdagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4Fjolårets svenska derbyfinalist <strong>Monastery Boko</strong> (e. Chelsea Boko) gör ikväll debut på finsk mark och för sin nya tränare Jukka-Pekka Hukkanen.</p>



<p class="wp-block-paragraph">Femåringen som köptes av Kemppitalli Oy under fjolåret körs av Kimmo Kemppi i premiärloppet i vårt östra grannland och där gör även 2023 års finska derbyvåa <strong>Corazon Combo </strong>(e. Express Duo) säsongens första framträdande.</p>



<p class="wp-block-paragraph"><strong>Startlista</strong><br><em>1.620 meter autostart</em></p>



<ol class="wp-block-list">
<li>Effronte Photo – Jukka Torvinen</li>



<li>Lexus Dream – Olli Koivunen</li>



<li>American Hero – Iikka Korpi</li>



<li>Grainfield Aiden – Hannu Korpi</li>



<li>Monastery Boko – Kimmo Kemppi</li>



<li>Ciak Bi – Riku Salminen</li>



<li>Hotshot Luca – Hannu Torvinen</li>



<li>Corazon Combo – Pekka Korpi</li>



<li>Cash Maker – Tapio Perttunen</li>
</ol>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/08/monasteryboko-617x333.jpg" alt="" class="wp-image-490554"/><figcaption class="wp-element-caption">Monastery Boko har exporterats till Finland och gör ikväll debut i ny regi. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<p class="has-drop-cap wp-block-paragraph">5Årets tredje etapp av den franska rikstäckande löpningsserien Grand National du Trot (€90.000) ska idag avgöras i Lyon La Soie (första start kl. 13.55).</p>



<p class="wp-block-paragraph">Sam Bourbon-sonen <strong>Horchestro</strong> som gick segrande ur striden i den andra etappen i Marseille för två veckor sedan finns med i deltagarskaran och lär få bära på favoritskapet tillsammans med Jean-Michel Bazire-tränade <strong>Hymne du Gers</strong> (e. Bold Eagle) som körs av Nicolas Bazire.</p>



<p class="wp-block-paragraph">Ur blågul synvinkel är evakueringsloppet Prix de Nantes (€34.000) än mer intressant. Loppet är öppet för sex- till elvaåriga hästar som tjänat upp till 186.000 euro och bland de elva deltagarna är fem svenskfödda.</p>



<figure class="wp-block-image alignright size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/12/00243165012scoopdyga-617x411.jpg" alt="" class="wp-image-538605"/><figcaption class="wp-element-caption">Global Agreement var bäst av de svenskfödda hästarna med tre vinster i Paris under vintermeetinget. Foto: Scoopdyga</figcaption></figure>



<p class="wp-block-paragraph">Jörgen S Eriksson är själv på plats för att köra <strong>Dollar Doc </strong>(e. Ready Cash) som går upp i ringen mot Alessandro Gocciadoros <strong>Global Agreement </strong>(e. Love You) och Vincent Martens <strong>King Cole</strong> (e. Maharajah).</p>



<p class="wp-block-paragraph">Global Agreement är obesegrad i Alessandro Gocciadoros regi efter fem starter och tre av triumferna är tagna på Vincennes. Före nyår styrde Gabriele Gelormini hästen till vinst och det är även han som kuskar bakom den åttaårige valacken i dagens lopp som avgörs i högervarv och lockar med en segerpremie på 15.300 euro.<br>Övriga svenskhopp är exporterna <strong>Viking Brodde </strong>(e. Muscle Hill) och <strong>Madame af Djupmyra</strong> (e. Formula One).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/lyon-la-soie-2024-04-10/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna i Lyon.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">6Erland Olsson i Falkenberg har satsat friskt som hästägare de senaste åren och äger i nuläget 15 ung- och tävlingshästar.</p>



<p class="wp-block-paragraph">Efter att tidigare haft merparten av dem i träning hos Johan Svensson står nu Olsson utan häst i träning hos Åbyproffset och har istället placerat 13 av dem hos Halmstads Magnus Dahlén.</p>



<p class="wp-block-paragraph">Bland dem finns miljonärerna<strong> Kuyt F.Boko</strong> (e. Conway Hall) 1.11,8am/2.297.398 kr samt <strong>Fire N&#8217;Fury </strong>(e. Explosive Matter) 1.11,3ak/1.224.406 kr.</p>



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



<p class="has-drop-cap wp-block-paragraph">7De senaste veckorna har vi rapporterat om flera häftiga kvaltider från holländska Wolvega här i Morgonsvepet, men idag riktar vi blickarna mot svensk och norsk mark.</p>



<p class="wp-block-paragraph">Vid gårdagens kvallopp på Sundbyholmstravet var Markus B Svedbergs treårssto <strong>Lovely Rita </strong>(e. Greenshoe–All For You) först i mål på 1.16,4/2.140 meter efter att växlat ner Daniel Redéns hingst<strong> Beautiful James </strong>(e. Propulsion–Talk Talk) stegen före mål.</p>



<p class="wp-block-paragraph">Svedbergs häst tassade med i rygg på Beautiful James som anförde fältet, tog några snubbelsteg vid utgången av slutkurvan, men fann snabbt rytmen och levererade ett upplopp i överljudsfart.</p>



<p class="wp-block-paragraph">Stoet bet i med 1.10 sista 700 meterna (!) och är den första svenskregistrerade avkomman till Ask For You (e. Love You) 1.10,5ak/1.612.579 kr som vann 15 av 37 starter i Robert Bergh och Marcus Lindgrens regi under sin karriär.</p>



<p class="wp-block-paragraph">På norska nationalarenan Bjerke kvalade i sin tur svenskfödda treårsstoet <strong>Grande Finale</strong> (e. Muscle Hill–Olympia Tilly) på 1.16,1/2.140 meter för Magnus Teien Gundersen och här finns det onekligen lite att brås på&#8230;</p>



<p class="wp-block-paragraph">Stoet är nämligen halvsyster till såväl<strong> Calgary Games</strong> (e. Readly Express) 1.11,7al/6.685.000 kr som fjolårets Kriterievinnare <strong>Fame and Glory </strong>(e. Tactical Landing) 1.12,5al/5.260.000 kr och ser sannerligen inte ut att vansläktas.</p>



<p class="wp-block-paragraph"></p>

Fokustema
Morgonsvepet
Läs senare
Profilhäst i skymundan
Om kvällens namnstarka, men tunt beklädda startfält på Solvalla, årspremiär på Nordens kanske vackraste travbana samt att en fjolårets svenska derbyfinalister gör årsdebut på finsk mark går bland annat att läsa i veckans tredje morgonsvep.
