
<p class="has-drop-cap wp-block-paragraph">1 Klockan 15.15 släpps <a href="https://sulkysport.se/gapar-hogst-i-prix-de-france/" target="_blank" rel="noreferrer noopener">Prix de France</a> (€400.000) iväg på Vincennes och fyra svenskar ställer upp och den som har bäst chans på papperet – om man ska tro franska tidningar – är <strong>Don Fanucci Zet</strong> (e. Hard Livin) och Örjan Kihlström.</p>



<p class="wp-block-paragraph">En tidning – Le Confidentiel – rankar Daniel Redéns travare etta. Allra flest röster i 20 tidningars tips får <strong>Ampia Mede Sm</strong> (11), följd av <strong>Hooker Berry</strong> (4), <strong>Vivid Wise As</strong> (2) och en röst vardera på tidigare nämnde <strong>Don Fanucci Zet</strong>, <strong>Beads</strong> och <strong>Horsy Dream</strong>.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2022/05/00210610007scoopdyga-scaled.jpg" alt="" class="wp-image-308087"/><figcaption class="wp-element-caption">Ampia Mede Sm flög fram till andraplatsen i Prix d&#8217;Amerique. Revansch i Prix de France? Foto: Scoopdyga.</figcaption></figure>



<p class="wp-block-paragraph">Frankrikes största travtidning Paris-Turf har följande rank till Prix de France: Hooker Berry, Ampia Mede Sm, Hohneck, Horsy Dream, <strong>Don Fanucci Zet,</strong> Vivid Wise As, Beads, Hip Hop Haufor, Delia du Pommereux, Vernissage Grif, Go On Boy, <strong>Dear Friend</strong>, Gu d’Heripre, <strong>Honey Mearas</strong>, <strong>Imhatra Am</strong> och Fado du Chene.</p>



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



<p class="has-drop-cap wp-block-paragraph">2 Prix d’Amérique-favoriten <strong>Idao de Tillard </strong>(e. Severino) plockades sent bort ur Prix de France, men kommer likväl till start under eftermiddagens tävlingar på Vincennes (13.23).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/03/selection3-617x299.jpg" alt="" class="wp-image-274361"/><figcaption class="wp-element-caption">Idao de Tillard och Clément Duvaldestin vinner Prix de Sélection. Foto: Gerard Forni</figcaption></figure>



<p class="wp-block-paragraph">Thierry Duvaldestin har valt att matcha hästen i femåringsloppet Prix Ovide Moulinet (€120.000) där konkurrenterna bara är sex till antalet, men sannerligen av hög klass.</p>



<p class="wp-block-paragraph">Prix d’Amérique-trean <strong>Italiano Vero</strong> (e. Ready Cash) syns i listan liksom <strong>Instrumentaliste</strong> (e. Ready Cash) som besegrade den nämnda duon i december då de möttes i Prix Octave Douesnel (€120.000).</p>



<p class="wp-block-paragraph">Tomas Malmqvist prövar lyckan med två hästar. I Prix des Vosges (€57.000) gör elvaårige <strong>Crack Atout</strong> (e. Niky) en av sina sista starter på fransk mark och i Grupp III-klassade Prix de Rouen (€90.000) tar han chansen med <strong>Howdy Partner</strong> (e. Repeat Love).</p>



<p class="wp-block-paragraph"><a rel="noreferrer noopener" href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2023-02-12/" target="_blank">Här kan du ta del av dagens startlistor till tävlingarna på Vincennes.</a></p>



<p class="wp-block-paragraph"><strong>Så gick det för gårdagens svenskhopp på Vincennes:</strong><br><em>Hästnamn (far) – tränare – placering – prispengar</em></p>



<ul class="wp-block-list">
<li><strong>Jazzy Perrine</strong> (e. Django Riff) – Tomas Malmqvist – 4 – 9.600 euro</li>



<li><strong>Justess Viking </strong>(e. Ubriaco) – Marie Norberg – 0</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">3 <strong>Skelleftetravet</strong> har ett eget vintermeeting med tre tävlingsdagar på isbanan. Idag (första start 13.45) väntar vinterns andra och största tävlingsdag när Skellefteå är ensam på svens mark med Grand Slam 75-tävlingar.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2017/10/selmerih-617x309.jpg" alt="" class="wp-image-14513"/><figcaption class="wp-element-caption">Selmer I.H. Foto Mia Törnberg</figcaption></figure>



<p class="wp-block-paragraph">Bland hästarna som dyker upp finns hemmabanans stora stjärna <strong>Selmer I.H.</strong> (e. Love You), som verkligen trivs med förutsättningarna: vinter och isbana! Gabriella Laestanders fyrfaldige miljonär kommer närmast från gulddivisionsseger i finska Uleåborg med samma förutsättningar och har på sina sex senaste starter – alla på isbana – tagit fyra segrar och två andraplatser!</p>



<p class="wp-block-paragraph">En annan som visat att han trivs på isen är Jens Erikssons kallblod <strong>Fyrkrafs </strong>(e. Tekno Odin), som inlett året med två raka segrar i Boden. Nu ställs han bland annat mot <strong>Nordvinn </strong>(e. Månprinsen A.M.), som senast var tvåa bakom <strong>Bokli Rapp N.O.</strong> inom Umåker V75-omgång på juldagen.</p>



<p class="wp-block-paragraph">Två spännande ston årsdebuterar också i loppet – med helt olika förutsättningar. <strong>Mira Kiro</strong> (e. Bork Odin) vann Sleipner Cup-finalen för ston och kvalade in till norska Stoderbyt ifjol. Nu står hon på start i flerklassloppet, där fjolårets Sto-SM-trea <strong>Forspärla</strong> (e. Hallsta Lotus), 1.21,5ak/1.662.100 kr, jagar från 60 meters tillägg.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/02/12gs75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till söndagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4 Grupp III-loppet Gran Premio Mario Locatelli (€40.040) avgörs i Milano idag och tolv hästar har anmälts till loppet över sprinterdistans för äldre travare.</p>



<p class="wp-block-paragraph"><strong>Becoming</strong> (e. Brillantissme) har haft en stark inledning på 2023 med två Grupp III-vinster i Gran Premio della Vittoria (€40.040) och Gran Premio Ponte Vecchio (€40.040), men har lottats till bakspår i söndagens upplaga av Gran Premio Mario Locatelli, som avgjordes första gången 1995.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/02/1b3c85ff8b55c49df9f3a0c2735baa5baf707275-617x411.jpg" alt="" class="wp-image-409117"/><figcaption class="wp-element-caption">Becoming. Foto: La Maura/Milano</figcaption></figure>



<p class="wp-block-paragraph"><strong>Gran Premio Mario Locatelli</strong> (€40.040)<br><em>1.650 meter, autostart.</em></p>



<ol class="wp-block-list">
<li><strong>Ziguli dei Greppi</strong> (e. Uronometro) – Nicola Del Rosso</li>



<li><strong>Brillant Ferm</strong> (e. Nad al Sheba) – Andrea Farolfi</li>



<li><strong>Bonjovi Mmg</strong> (e. Ganymede) – Giampaolo Minnucci</li>



<li><strong>Achille Blv</strong> (e. Ganymede) – Vincenzo P Dell’Annunziata</li>



<li><strong>Vesna</strong> (e. Libeccio Grif) – Rene’ Legati</li>



<li><strong>Akela Pal Ferm</strong> (e. Maharajah) – Antonio di Nardo</li>



<li><strong>Brooklyn Lux</strong> (e. From Above) – Carmine Piscuoglio</li>



<li><strong>Generaal Bianco</strong> (e. Ufo Kievitshof) – Massimiliano Castaldo</li>



<li><strong>Vincero’ Gar</strong> (e. S.J.’s Photo) – Pietro Gubellini</li>



<li><strong>Becoming </strong>(e. Brillantissime) – Marco Stefani</li>



<li><strong>Cathrinelle</strong> (e. Filipp Roc) – Filippo Rocca</li>



<li><strong>Birba Caf</strong> (e. Orlando Vici) – Enrico Bellei</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">5 Förra året gick Tyskt Derby från ett lopp för tre- till fyraåringar. Nu lämnas inte treåringarna vind för våg, utan en ny penningstinn serie – värderad till 244.000 euro – kommer att avhållas på fem banor och där finalerna körs på Mariendorf-banan i Berlin.</p>



<p class="wp-block-paragraph">Den nya serien Dreijährigen-Kriterium för treåringar är uppdelad mellan hingstar/valacker och ston. Fyra försöksomgångar kommer att köras med 7.500/5.000 euro till vinnaren i respektive lopp och i finalerna – som har Grupp II-status – erhåller vinnarna 25.000 euro vardera.</p>



<p class="wp-block-paragraph">Med hjälp av PMU-medel (60.000 euro) kommer en stor del av insatserna att finansieras plus att de arrangerande banorna går in med egna medel så hålls kostnaderna nere för hästägarna.</p>



<p class="wp-block-paragraph">Dreijärhigen-Kriterium kommer – skriver Mariendorf-banan i ett pressmeddelande – bli permanent som ett av de framstående evenemangen i den tyska sulkysportens kalender.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/02/3js23.pdf" target="_blank" rel="noreferrer noopener">Första insatsen ska vara betalad senast den 1 mars (400 euro).</a></p>



<p class="wp-block-paragraph"><strong>Dreijärrigen-Kriterium Serie 2023:</strong></p>



<p class="wp-block-paragraph"><em>Datum – Bana – Förstapris (€)</em></p>



<ul class="wp-block-list">
<li>14 maj – <strong>München</strong> – 5.000 euro</li>



<li>4 juni – <strong>Gelsenkirchen</strong> – 5.000 euro</li>



<li>22 juni – <strong>Hamburg</strong> – 7.500 euro</li>



<li>23 juli – <strong>Berlin </strong>(Mariendorf) – 7.500 euro</li>



<li>5-6 augusti – <strong>Berlin </strong>(Mariendorf) – 25.000 euro</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">6 Två dopingdomar har kungjorts av Det Norske Travselskap. Kristian Malmin har dömts till 69.574 norska kronor efter att Miss America avlagt ett positivt dopingprov för mepvacaine på Momarken den 22 januari 2022.</p>



<p class="wp-block-paragraph">Jomar Blekkan får böta 42.818 norska kronor för felaktig journalföring av tio hästar som han var ansvarig tränare för.</p>



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



<p class="has-drop-cap wp-block-paragraph">7 Kerryn Manning och fyraårige <strong>Plymouth Chubb</strong> (e. Majestic Son-Pocket Fantasy) vann Grupp I-loppet Knight Pistol ($50.000) på Tabcorp Park Melton igår och travade 1.13,0a/2.240 meter. Bakom sig hade valacken duon Sleepe (e. Dejarmbro) och favoriten Majestic Man (e. Majestic Son).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/01/skarmavbild20220112kl.12.25.26-617x366.jpg" alt="" class="wp-image-258443"/><figcaption class="wp-element-caption">Plymouth Chubb.</figcaption></figure>



<p class="wp-block-paragraph">Segern igår var den 18:e karriären på 29 starter och närmare 330.000 dollar har den Peter Manning-tränade travaren tjänat. I sin näst senaste start vann Plymouth Chubb försök i Great Southern Star ($50.000), men slutade oplacerad i finalen.</p>



<p class="wp-block-paragraph">Segern igår vard en femte Grupp I-vinsten och tidigare har Plymouth Chubb vunnit Breeders Crown, Home Grown Classic, Redwood Classic och Vicbred Super Series.</p>



<p class="wp-block-paragraph">Mamman <strong>Pocket Fantasy</strong> (e. In the Pocket), 1.18,1/$38.135, bär ren passgångarstam – hos oss föga kända blodslinjer dessutom. Föruom Plymouth Chubb har hon lämnat också mor till <strong>My Skypocket</strong> (e. Skyvalley), 1.14,2/$132.768, och <strong>Edge Hill </strong>(e. Great Succes), 1.11,8*/$110.161.</p>



<p class="wp-block-paragraph">Plymouth Chubbs pappa Majestic Son är en <strong>Angus Hall</strong>-son med svenskfödde <strong>King Conch</strong>, bror till <strong>Viking Kronos</strong>, som morfar.</p>
