
<p class="has-drop-cap wp-block-paragraph">1 Den italienska sajten Gaet – Galoppo e Trotto – publicerade under gårdagen en lista över födelselandet på vinterns icke franska segerhästar på Vincennes.</p>



<p class="wp-block-paragraph">Hästar födda i Italien stod bokförda för 23 segrar på den franska nationalarenan kontratio fullträffar för svenskfödda hästar.<br>Två italienska hästar har därtill vunnit Grupp I-lopp under vintermeetinget i form av Prix Bold Eagle-vinnaren <strong>Cocco Bfc </strong>(e. Varenne) samt Prix de France-segrarinnan <strong>Ampia Mede Sm</strong> (e. Ganymede).</p>



<p class="wp-block-paragraph">Därtill är italienska hästar bokförda för fem Grupp II samt tre Grupp III-vinster medan Sverige blott har lyckats räkna hem ett Grupp III-lopp.<br>Då handlade det om Thierry Duvaldestin-tränade <strong>Oracle Tile</strong> (e. Ready Cash) som vann Prix Jean Rene Gougeon (€90.000) under Prix d&#8217;Amerique-söndagen.</p>



<p class="wp-block-paragraph">Någon statistik på hur många hästar från de olika nationerna som tävlat på Vincennes denna vinter går dock inte att ta del av, men det ska sägas att italienska hästar är kraftigt överrepresenterade bland de utländska inslagen och att det funnits fler lopp under detta vintermeeting där startfält utgjorts av fem eller fler italienska hästar i ett och samma lopp.</p>



<p class="wp-block-paragraph">Bland segrande hästar från övriga nationer står tyskfödda med fyra segrar, danska med två segrar och belgiska, holländska samt amerikanska hästar med en vardera.</p>



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



<p class="has-drop-cap wp-block-paragraph">2 Det första av fem meetings av nya Solvallaserien på onsdagar går i mål ikväll på Solvalla (första start 18.15). Tre finaler med 150.000 kronor till vinnare i varje väntar efter att fem försöksomgångar körts sedan nyår.<br>Av de 15 försöksvinnarna under vintern startar 14. Den ende som saknas är <strong>Mister Jigolo</strong> (e. Mister J.P.), som vann lägsta klassen i första försöksomgången i början av januari.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2023/01/portofinojdm230125adamstromstalltz-scaled.jpg" alt="" class="wp-image-404599"/><figcaption class="wp-element-caption">Portofino spurtade till vinst i ett av försöken Solvallaserien K150 tillsammans med sin tränare Jimmy Dahlman. Foto: Adam Ström/Stalltz.se.</figcaption></figure>



<p class="wp-block-paragraph"><strong>Försöksvinnarna som startar i finalerna:</strong></p>



<ul class="wp-block-list">
<li><strong>Solvallaserien 150: </strong>Bottnas Justin, Cash Forever, Michigan Bro, Portofino</li>



<li><strong>Solvallaserien 350:</strong> Global Above All, Global Classified, Drizzle, Mercenary, Wings Level</li>



<li><strong>Solvallaserien 650: </strong>Feel the Benefit, Final Whistle, Kalle Taxam, Twigs Honor, Xerxes Millpond</li>
</ul>



<p class="wp-block-paragraph">Ytterligare ett lopp på Solvalla har sexsiffrig check till vinnaren, nämligen Solvalla Hästägarförenings Vårvintervandringspris med 100.000 kronor i förstapris. Fjolårsvinnaren <strong>Dream Creation</strong> (e. Orlando Vici) finns med i även årets upplaga av loppet, där hästens ägare Stall Dream Team På Stället kan plocka med JOY:s vandringspris med en andra inteckning. Svante Ericsson tränar hästen som – precis som i fjolårets upplaga – körs av Claes Sjöström.</p>



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



<p class="has-drop-cap wp-block-paragraph">3 Två sjuåringar från samma bana med ungefär lika många starter och segrar bakom sig, men helt olika karriärer. I ett bra snabblopp på Jägersro (första start 18.27) möts de båda: <strong>Four Guys Dream</strong> (e. Dream Vacation) och <strong>Aetos Kronos</strong> (e. Bold Eagle).</p>



<p class="wp-block-paragraph">Håkan K Perssons stjärna Four Guys Dream har sakta och metodiskt arbetat sig igenom klasserna. Han var nämligen inte anmäld till de klassiska unghästloppen och har istället varit flitigt återkommande i STL-sammanhang. Hela 22 starter (5-5-1) har gjorts inom rikstoton, där han efter tredjeplatsen i silverdivisionens final på Solvalla annandag jul nu tagit sig hela vägen till gulddivisionen.<br>För Aetos Kronos har det varit raka motsatsen. Redan som tvååring var han trea i Svensk Uppfödningslöpning. Som treåring plockade han med Breeders Course-finalen och dubbla E3-finaler. Som fyraåring blev det vinst i Kungapokalen och tredjeplats i Svenskt Travderby och året efter seger i Jubileumspokalen och tredjeplats mot världseliten i Prix de France. Nu kämpar han för att komma tillbaka efter den förlamning och sjukdom som drabbade hingsten hösten 2021.</p>



<p class="wp-block-paragraph">En gedigen klassklättrare eller en häst som var stjärna redan som tvååring – vem är bäst? Ett dagsfärskt svar kommer ikväll.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/02/15v86.pdf" target="_blank" rel="noreferrer noopener">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">4 Jean-Michel Bazire ådrog sig fyra dagars avstängning (23-26 februari) i samband med söndagens Prix de France för att ha stört två medtävlare.<br>Det mest noterbara kring det är att det var stallkamraten <strong>Hooker Berry</strong> som han störde bakom sin styrning <strong>Beads</strong> som i sin tur påverkade framfarten för <strong>Hip Hop Haufor</strong>.</p>



<p class="wp-block-paragraph">I Frankrike får man dock dispens för att köra Grupp I-lopp under avstängningsperioden vilket innebär att Bazire kan köra Prix de Paris den 26 februari.</p>



<p class="wp-block-paragraph">Idag lyser de blågula svenskhoppen med sin frånvaro på fransk mark, men såhär gick det för de som försökte på Vincennes under gårdagen:</p>



<p class="wp-block-paragraph"><em>Hästnamn (far) – tränare – placering – intjänade prispengar:</em></p>



<ul class="wp-block-list">
<li><strong>M.T.Oscar</strong> (e. Yarrah Boko) – Tomas Malmqvist – 3:a – 6.680€</li>



<li><strong>Gardner Shaw</strong> (e. Ready Cash) – Yannick Henry – 4:a – 3.920€</li>



<li><strong>Criterion</strong> (e. Jocose) – Fredrik Wallin – opl.</li>



<li><strong>Mister Donald </strong>(e. Niky) – Björn Goop – opl.</li>



<li><strong>Kash Madrik</strong> (e. Ready Cash) – Tomas Malmqvist – 3:a – 4.480€</li>



<li><strong>Icone de &#8217;Etre</strong> (e. Brillantissime) – Fredrik Wallin – 2:a – 8.250€</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">5 Ett av Sveriges bättre kallblod står skadad. Det är Travronden som uppmärksammar att <strong>Ulvsåsen</strong> (e. Åsajerven) 1.22,3m/1.084.400 kr dragit på sig en gaffelbandsskada och ser ut att missa hela säsongen.<br>– <em>Det känns väldigt tomt och det går inte att säga annat än att man blir lite deppig. Jag hade verkligen sett framemot året med honom och låta honom fortsätta etablera sig i eliten, förra året var han med i både SM och på Solvalla under Jubileumspokalskvällen</em>, säger hästens tränare Anders Wallin till Travronden.</p>



<p class="wp-block-paragraph">Ulvsåsen har segrat i 14 av karriärens 27 starter varav den största triumfen kom i finalen av Dubbelcupen på Gävletravet den 21 maj ifjol.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/05/ulvsasen-617x333.jpg" alt="" class="wp-image-166385"/><figcaption class="wp-element-caption">Anders Wallin-tränade Ulvsåsen tillsammans med Per Linderoth. Foto Ellinor Kempe/ALN</figcaption></figure>



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



<p class="has-drop-cap wp-block-paragraph">6 Anders Svanstedt har haft en mycket stark inledning av detta år med åtta tränarsegrar och 529.400 kronor inkört till stallet.<br>Nu har en häst åter anslutit till stallet med potential att snygga till siffrorna ytterligare då From Above-dottern <strong>Cash and Carry</strong>, 1.11,3ak/628.250 kr är tillbaka hos Svanstedt.<br>Vintern har tillbringats på fransk mark i Björn Goops regi, men där blev det inte en enda intjänad euro på tre försök.</p>



<p class="wp-block-paragraph">I somras tog Cash and Carry karriärens hittills största seger då hon vann ett Klass I-försök i Tingsryd på 1.11,3a/1.609 meter.</p>



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



<p class="has-drop-cap wp-block-paragraph">7 Du tar väl chansen att spela V86 tillsammans med Sulkysport denna onsdagkväll?<br>Det är för årstiden riktigt bra sport på programmet, men även några tunga fvaoriter som vi redan nu kan avslöja att vi kommer göra ett försök att fälla.<br>Sulkysports V86-tips publiceras som vanligt klockan 12:00 och du som vill spela V86 tillsammans med Sulkysport kan välja mellan nedanstående alternativ:</p>



<p class="wp-block-paragraph"><a rel="noreferrer noopener" href="https://www.atg.se/andelskungen/spel/206233_V86_2023-02-15_40_1" target="_blank">Sulkysport Lilla V86 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a rel="noreferrer noopener" href="https://www.atg.se/andelskungen/spel/206235_V86_2023-02-15_40_1" target="_blank">Sulkysport Stora V86 – 15 andelar á 250 kr/styck</a></p>

Fokustema
Morgonsvepet
Läs senare
Italien utklassar Sverige
Siffror som visar på tydlig italiensk dominans på Vincennes, om kvällens finaler av Solvallaserien samt att ett av landets bästa kallblod blivit skadad går bland annat att läsa i dagens morgonsvep.
