
<p class="has-drop-cap">Det är jackpot ännu en gång på V75 denna vecka och prognosen säger att sjurättspotten kan komma att innehålla 55 miljoner kronor.</p>



<p>Örebrotravet står som värd för omgången och där brukar ledningen vara extra mycket guld värt då banan har ett kort upplopp.</p>



<p>Vi spelar med dubbla spetsspikar och tror att såväl <strong>Maserati Hall</strong> (V75-4) som <strong>Global Classified</strong> (V75-6) löser sina respektive lopp från just den positionen.</p>



<p>Det gör att vi kan kosta på oss att gardera &#8221;megalampan&#8221; <strong>Jalapeno K.</strong> (V75-7) i avslutningen. Det finns faktorer som talar för att han också hittar till ledningen, men det är på intet vis givet och vi finner därtill två riktigt bra konkurrenter som vi ogärna spelar utan på systemet.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/02/24v75.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistor till tävlingarna i Örebro.</a></p>



<p><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p><a href="https://www.atg.se/andelskungen/spel/206687_V75_2024-02-24_32_5" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206688_V75_2024-02-24_32_5" target="_blank" rel="noreferrer noopener">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206689_V75_2024-02-24_32_5" target="_blank" rel="noreferrer noopener">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>



<h2 class="wp-block-heading">Avd 1 – Klass I, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Global Depandable</strong> backades ner som sistahäst från spår åtta senast i Klass II-finalen och var utan chans att ta något i slutskedet. Han gick helt okej i skymundan, visade rejäla takter vid segern i samma klass gången innan och gäller som knapp spetsfavorit. Det är tillräckliga faktorer för att vi ska tippa honom etta, men totalt sett är loppet öppet.</li>



<li><strong>Mister Vredebest </strong>har gjort toppinsatser i vinter och verkligen samlat ihop till den seger som just nu saknas i resultatraden. Hästen hamnade helt på vingel initialt senast i STL-finalen, backades ner i kön, men avslutade rappt mellan hästar i skymundan. Är han bara med på noterna och trampar iväg från snävt spår är han högaktuell för slutstrid för den här hästen har en mycket vass speed om den får sparas in i det längsta.</li>



<li><strong>Joint Chef </strong>höll bra som dödenstvåa bakom Natural Mine senast i final av Solvallaserien. Han har inte startat på en och en halv månad efter det, men det är inget som oroar oss nämnvärt utan detta är en häst som brukar leverera bara han är frisk och fräsch.</li>



<li><strong>Conrads Palle </strong>gör nästan aldrig en dålig insats, men i lite mer penningstinna lopp har han haft svårt att stå som vinnare. Lyckas Markus B Svedberg ge hästen ett rygglopp här så ska femåringen vara en av de mer aktuella hästarna i loppet.</li>



<li><strong>Pwojtech Vrijthout </strong>spetsvann ett 100.000 kronorslopp senast utan att vara helt på topp. Han står hårt inne i klassen och vi tycker det är svårt att bedöma med bestämdhet hur bra han är för sammanhanget även om det handlar om en segervan häst.</li>
</ul>



<p><strong>Rank:</strong></p>



<p><strong>A: </strong>1-2-5-3<strong> B: </strong>4-9-7-6-8<strong> C: </strong>12-10-11</p>



<p><strong>Spetsstriden: Global Dependable </strong>är knapp spetsfavorit, men man ska ha klart för sig att det finns raska hästar från springspår i det här loppet i form av <strong>B.W.L.Fighter</strong> och <strong>Oh Cean</strong> så här kan favorit riskera att bli snuvad på tät.</p>



<h2 class="wp-block-heading">Avd 2 – Diamantstoet, 2.100 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Gelato Pellini </strong>löste ett sprinterlopp från dödens senast på Axevalla och var klart rejäl den dagen. Här är konkurrensen hårdare och det föreligger risk att hon får traska i samma position ånyo, men vi tycker att Trixton-stoet var så pass rejäl vid senaste segern att det likväl är hon som ska vara favorit.</li>



<li><strong>Cypress Point</strong> tog inte en pallplacering under karriärens första 45 starter, men ser ut som en helt ny häst i Tomas Malmqvists regi. Hon körs av en för sammanhanget mycket duktig kusk och känns glödhet i det här loppet bakspår till trots.</li>



<li><strong>Made For Metalimo </strong>plockade ner <strong>Eva Kant Gar </strong>från utsidan senast på Jägersro och fick äntligen räkna hem den seger som hon gjort sig förtjänt av. Stoet är ingen raket initialt, men har tveklöst styrka nog för att komma in i matchen likväl.</li>



<li><strong>I Love Faux Depart </strong>sköt till bra efter smyglopp senast på Åby som tvåa och har startspår nog för att få ett liknande löpningsförlopp här om hon rentav inte lyckas svara upp ledningen.</li>



<li><strong>Vicky Montoya </strong>lever främst på sin styrka och skulle gynnas av en tuff inledning på det här loppet då hon inte är någon startraket.</li>
</ul>



<p><strong>Rank:</strong></p>



<p><strong>A: </strong>4-11-5-1 <strong>B: </strong>3-2-9-8-12<strong> C: </strong>7-10-6</p>



<p><strong>Spetsstriden:</strong> <strong>I Love Faux Depart</strong> och <strong>Gelato Pellini </strong>håller vi som klart hetast i spetsjakten och påminner om att det inte är enkelt att fronta från innerspår i Örebro även om det inte är lika utmanande som det var förr om åren.</p>



<h2 class="wp-block-heading">Avd 3 – Gulddivisionen, 2.100 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Dark Roadster </strong>fick omöjligt långt fram senast i STL Champions där han inledde från tillägg och det var ingenting att säga något om att han inte fick några prispengar med sig hem. Nu är det åter tävling i Gulddivisionen som gäller samt autostart och det innebär att den gynnsamma jänkarvagnen åter åker på. Även om han inte kommer förbi Chapuy initialt så kan Dark Roadster lösa uppgiften med sin giftiga speed.</li>



<li><strong>Chapuy</strong> var tillbaka som en vinnare senast på hemmaplan efter att kommit fram fint till tredje utvändigt från dubbla tillägg och kunnat spara speeden. Han brukar trivas förträffligt denna årstid, har alla möjligheter att vinna starten och ger sig oftast ogärna från den positionen.</li>



<li><strong>Beartime</strong> fick dra &#8221;tåget&#8221; på slutvarvet i STL Champions och gick sig trött på kuppen. Galoppen kom vid upploppets början och det går inte att klandra hästen för då han hade sprungit på sig duktigt med mjölksyra. Spår tolv i Örebro är sannerligen inget drömläge, men får han rygghjälp och kan spara speeden kommer han garanterat leverera över spurtrakan.</li>



<li><strong>Dwayne Zet </strong>vann Gulddivisionen i Gävle före nyår, men kom inte till i samma klass i den efterföljande starten. Nu är han tillbaka från framspår vilket är klart gynnsamt för hans del.</li>



<li><strong>Dats So Cool </strong>brukar hävda sig väldigt väl i denna klass och i synnerhet den kalla årstiden, men just nu föreligger det formfrågetecken.</li>
</ul>



<p><strong>Rank:</strong></p>



<p><strong>A: </strong>5-2-12 <strong>B: </strong>4-8-10-3-7-11-9-6 <strong>C: </strong>1</p>



<p><strong>Spetsstriden: Chapuy</strong> och<strong> Dark Roadster </strong>gör upp. Båda är kusligt startsnabba, men kanske att vi tycker Chapuy är aningen raskare när han står med spår lite längre ut bakom vingen&#8230;</p>



<h2 class="wp-block-heading">Avd 4 – Flerklasslopp, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Maserati Hall </strong>drog fram vinnaren Bear High senast i Margaretas Tidiga Unghästserie och föll med flaggan i topp. Det var en mycket stark prestation som tvåa och hästen bör rimligtvis vara ytterligare lite förbättrad till denna start då han inte hade startat på två månader dessförinnan. Från innerspår i volten håller vi Maserati Hall som klar spetsfavorit.</li>



<li><strong>Jopp</strong> har haft en jättefin vinter på svensk mark och det finns inget som tyder på att det ska behöva ta emot nu bara för att han kommit upp i klass. Hästen gnuggade på utan rygg i tredjespår de sista 800 meterna senast vid segern i Solvallaserien, men löste likväl uppgiften trots det tuffa upplägget vilket var imponerande.</li>



<li><strong>Great Time Trot </strong>vann ett Klass II-försök i Bollnäs i september och känns som ett spännande nyförvärv i Ulf Stenströmers regi. Det faktum att han tar ut hästen i ett 100.000 kronorslopp direkt tolkar vi som att han är nöjd med sitt förvärv och placerar Walner-sonen i A-gruppen.</li>



<li><strong>Adthemission</strong> håller vi inte som någon superhäst i grunden, men formmässigt är han bättre nu än någonsin tidigare. Lyckas Erik Adielsson lirka iväg hästen felfri och kanske rentav kan droppa ner i rygg på Maserati Hall så kan allt hända bara luckan kommer till slut.</li>



<li><strong>Bold Knick </strong>lever tveklöst främst på sin styrka även om han blivit allt snabbare i benen i takt med ökad rutin och ålder. Han känns som det hetaste budet från tilläggsvolten.</li>
</ul>



<p><strong>Rank:</strong></p>



<p><strong>A: </strong>1-3-5 <strong>B: </strong>2-10-14-9-12-7-4-8 <strong>C: </strong>11-6</p>



<p><strong>Spetsstriden: Maserati Hall</strong> är klar spetsfavorit i lag med lika startsnabbe Carl Johan Jepson som pilot. Springspårshästarna utmanar, men vi har ändå svårt att se dem ta sig förbi.</p>



<h2 class="wp-block-heading">Avd 5 – Klass II, 2.609 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Baron Tilly </strong>blev det lite många ben på kort efter start i elddopet senast i Margaretas Tidiga Unghästserie och hästen slog på en galopp. Inget ont som inte för något gott med sig utan hästen står därmed kvar i en relativt låg klass och kan testa lyckan inom STL. Vi tycker att han sett helt okörd ut vid tidigare segrar och nu frångår man den lättning man gjort i balansen i de två senaste starterna och kör åter med järnskor. Vi tror att han har högst segerchans, men det finns ett vädigt motbud.</li>



<li><strong>Blackhawk Face</strong> är hästen vi har i åtanke. Han är inte helt att lita på och i någon mån framstår han alltjämt som en oslipad grovjobbare, men att det finns väldigt stort kunnande i femåringen råder ingen som helst tvivel om. Senast joggade hästen från sina konkurrenter via en rejäl 700 metersrepa och vi tror att Adrian Kolgjini blint litar på hästens styrka i det här loppet.</li>



<li><strong>Hoohoo Haahaa</strong> slog likt Baron Tilly på en galopp i Margareta-loppet på Solvalla och får ladda om här. Han höll starkt från ledningen som tvåa i ett V75-lopp hemma på Axevalla den 31 december bakom <strong>Take Your Time</strong>, men nu tror vi att man släpper ledningen om det är så att Baron Tilly utmanar i tidigt skede.</li>



<li><strong>Cocolicious</strong> är också aspirant på ledningen. Hon har verkligen lyft under vintern övertygat i enklare sällskap. Här hårdnar konkurrensen rejält och vi ser henne främst som en outsider.</li>



<li><strong>Staro Royal Mark </strong>avslutade klart bra som trea i samma klass i lördags från ett liknande utgångsläge. Hanterar han täta starter på rätt sätt så kan han vara med och slåss om tätplatserna även denna gång, men vi tror att våra A-hästar har högre kapacitet i grunden.</li>
</ul>



<p><strong>Rank:</strong></p>



<p><strong>A: </strong>6-7 <strong>B: </strong>2-3-11 <strong>C: </strong>9-5-1-12-8-4-10</p>



<p><strong>Spetsstriden: Hoohoo Haahaa</strong> och <strong>Chocolicious</strong> bedömer vi som snabbast initialt, men tror att <strong>Baron Tilly</strong> får överta i skede två för här handlar det &#8221;bara&#8221; om att hålla ut <strong>Blackhawk Face </strong>för hans del.</p>



<h2 class="wp-block-heading">Avd 6 – Silverdivisionen, 1.609 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Global Classified </strong>trivs förträffligt i lag med Magnus A Djuse som vaket skickade hästen till ledningen senast i Silverdivisionens final. Sexåringen övertygade den dagen och då vi tillmäter honom störst chans att nå just tät även i det här loppet så ska han gälla som favorit.</li>



<li><strong>L.A.Boko </strong>börjar närmast bli en institution i Silverdivisionen. Han jagar snabb revansch efter förra veckans underliga galopp i dödspositionen halvvägs in i loppet, men Daniel Wäjersten hade givetvis inte anmält hästen till det här loppet om han trodde att något var fel på sin springare. På sin högstanivå är L.A.Boko tveklöst bra nog för att matcha topparna i det här loppet.</li>



<li><strong>Run N&#8217;Cola </strong>stod för en ruskig upphämtning efter startgalopp i Silverdivisionens final och nådde femteplatsen. Hästen är utan seger i resultatraden, men det är bara en tidsfråga innan han får &#8221;vända upp&#8221; på nytt för det var längesen hästen var i så pass god form som han är just nu.</li>



<li><strong>Danao degli Dei </strong>höjde Alessandro Gocciadoro till skyarna i våras och han inledde också sin sejour på svensk mark med att vinna på 1.10,4a/1.640 meter. Därefter var resultaten blandade, men nu har han återfunnit stilen med besked i Adrian Kolgjinis regi. Den här hästen har &#8221;hur mycket som helst&#8221; i sig, men från spår tolv över sprint går det inte blunda för att uppgiften är mycket tuff.</li>



<li><strong>Hipster Am</strong> blev stressad från det lömska innerspåret bakom bilen senast och galopperade direkt. Upphämtningen var mycket god, men det känns lottobetonat att läsa in honom positionsmässigt i det här loppet från spår åtta bakom bilen.</li>
</ul>



<p><strong>Rank:</strong></p>



<p><strong>A:</strong> 6 <strong>B: </strong>4-5-12-8-7-2-3 <strong>C: </strong>9-11-1-10</p>



<p><strong>Spetsstriden: Lord Horse</strong> och <strong>Declan</strong> är båda riktigt raska initialt, men vi tror ändå inte att någon av dem tar emot <strong>Global Classified</strong>.</p>



<h2 class="wp-block-heading">Avd 7 – Bronsdivisionen, 2.100 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Jalapeno K.</strong> bombade till tät i Klass I-finalen senast på Solvalla och var aldrig nära att släppa greppet om det loppet. Tvärtom så gick han ifrån till en överlägsen seger och såg ut att ha gott om krafter kvar i behåll över målskjutsen. Förutsättningarna här är mycket passande ch vi har ingen anledning att tro att det ska behöva ta emot nu bara för att han gått upp i klass.</li>



<li><strong>Doctor Gio</strong> klarade inte av voltstart senast i STL Champions utan straffade ut sig med galopp. Gången innan travade han som en klocka och anförde från start till mål. Femåringen var mycket bra som dödenstvåa på 1.10,5 i Axel Jensens Minneslopp i november och ska hävda sig väl i Bronsdivisionen även om han skulle få ett tyngre lopp än favoriten.</li>



<li><strong>Winterburn</strong> fick gå ett tufft slutvarv senast i Klass I-finalen och höll med tanke på det starkt till andraplatsen bakom Jalapeno K. Ready Cash-sonen har en härlig inställning, tycks aldrig göra en dålig insats och kan säkert köras offensivt trots spår åtta.</li>



<li><strong>Wings Level </strong>har spåret invändigt då han precis som i lördags inleder från spår sju. Då kördes han passivt och gick i mål med sparade krafter, men frågan är om han får ut något av det här nu när han åter drog nitlotten i spårtombolan.</li>



<li><strong>Nail&#8217;em</strong> fick ge vika från ledningen senast, men det var en pilsnabb avslutning och han kunde helt enkelt inte springa fortare. Åke Lindbloms häst känns förhållandevis allround och är inte chanslös med ett rygglopp om favoriten skulle ha en sämre dag.</li>
</ul>



<p><strong>Rank:</strong></p>



<p><strong>A: </strong>2-6 <strong>B: </strong>8-7-5-3 <strong>C: </strong>1-9-10-11-12-4</p>



<p><strong>Spetsstriden: </strong>Fördel för<strong> Jalapeno K. </strong>även om han är än mer explosiv med spår längre ut bakom bilen. <strong>Merci Bråten</strong> och<strong> Nail&#8217;em </strong>är de tänkbara spetshoten, men även <strong>Doctor Gio</strong> kan vara med bra på noterna.</p>



<p>	
				<div class="factbox full ">
			<div class="insidefactbox">
				<div class="overflow">
					<div class="height">
						<div class="padding">
							<div class="factvinjett">Fakta</div>
							
															<h3 class="title">
									V75-FÖRSLAGET 24 FEBRUARI								</h3>
														<div class="content">
								
<p><strong>Avd 1: </strong>1,2,3,4,5,6,7,8,9 (12,10)<br><strong>Avd 2: </strong>1,2,3,4,5,8,9,11 (12,7)<br><strong>Avd 3: </strong>2,3,4,5,7,8,10,11,12 (9,6)<br><strong>Avd 4: </strong>1 Maserati Hall (3,5)<br><strong>Avd 5: </strong>6,7 (2,3)<br><strong>Avd 6: </strong>6 Global Classified (4,5)<br><strong>Avd 7:</strong> 2,6,8 (7,5)</p>



<p><em>3.888 rader / 1.944 kronor</em></p>
							</div>
						</div>
					</div>
				</div>
							</div>
		</div>
	
	</p>
